Skunkware 98/Skunkware 98.iso/src/net/bind-contrib.tar.gz/bind-contrib.tar/contrib/host/host.c

C/C++ Source or Header | 1996-11-10 | 191.3 KB | 7,867 lines

/*
 * Copyright (c) 1985, 1989 Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms are permitted
 * provided that: (1) source distributions retain this entire copyright
 * notice and comment, and (2) distributions including binaries display
 * the following acknowledgement:  ``This product includes software
 * developed by the University of California, Berkeley and its contributors''
 * in the documentation or other materials provided with the distribution
 * and in all advertising materials mentioning features or use of this
 * software. Neither the name of the University nor the names of its
 * contributors may be used to endorse or promote products derived
 * from this software without specific prior written permission.
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */

/*
 * Originally, this program came from Rutgers University, however it
 * is based on nslookup and other pieces of named tools, so it needs
 * that copyright notice.
 */

/*
 * Rewritten by Eric Wassenaar, Nikhef-H, <[e-mail]>
 *
 * The officially maintained source of this program is available
 * via anonymous ftp from machine 'ftp.nikhef.nl' [192.16.199.1]
 * in the directory '/pub/network' as 'host.tar.Z'
 *
 * You are kindly requested to report bugs and make suggestions
 * for improvements to the author at the given email address,
 * and to not re-distribute your own modifications to others.
 */

#ifndef lint
static char Version[] = "@(#)host.c    [e-mail] (Eric Wassenaar) 961013";
#endif

#if defined(apollo) && defined(lint)
#define __attribute(x)
#endif

#define justfun            /* this is only for fun */
#undef  obsolete        /* old code left as a reminder */
#undef  notyet            /* new code for possible future use */

/*
 *            New features
 *
 * - Major overhaul of the entire code.
 * - Very rigid error checking, with more verbose error messages.
 * - Zone listing section completely rewritten.
 * - It is now possible to do recursive listings into delegated zones.
 * - Maintain resource record statistics during zone listings.
 * - Maintain count of hosts during zone listings.
 * - Check for various extraneous conditions during zone listings.
 * - Check for illegal domain names containing invalid characters.
 * - Verify that certain domain names represent canonical host names.
 * - Perform ttl consistency checking during zone listings.
 * - Exploit multiple server addresses if available.
 * - Option to exploit only primary server for zone transfers.
 * - Option to exclude info from names that do not reside in a zone.
 * - Implement timeout handling during connect and read.
 * - Write resource record output to optional log file.
 * - Special MB tracing by recursively expanding MR and MG records.
 * - Special mode to check SOA records at each nameserver for a zone.
 * - Special mode to check reverse mappings of host addresses.
 * - Extended syntax allows multiple arguments on command line or stdin.
 * - Configurable default options in HOST_DEFAULTS environment variable.
 * - Implement new resource record types from RFC 1183 and 1348.
 * - Basic experimental NSAP support as defined in RFC 1637.
 * - Implement new resource record types from RFC 1664 and 1712.
 * - Implement new resource record types from RFC 1876 and 1886.
 * - Code is extensively documented.
 */

/*
 *            Publication history
 *
 * This information has been moved to the RELEASE_NOTES file.
 */

/*
 *            Compilation options
 *
 * This program usually compiles without special compilation options,
 * but for some platforms you may have to define special settings.
 * See the Makefile and the header file port.h for details.
 */

/*
 *            Miscellaneous notes
 *
 * This program should be linked explicitly with the BIND resolver library
 * in case the default gethostbyname() or gethostbyaddr() routines use a
 * non-standard strategy for retrieving information. These functions in the
 * resolver library call on the nameserver, and fall back on the hosts file
 * only if no nameserver is running (ECONNREFUSED).
 *
 * You may also want to link this program with the BIND resolver library if
 * your default library has not been compiled with DEBUG printout enabled.
 *
 * The version of the resolver should be BIND 4.8.2 or later. The crucial
 * include files are <netdb.h>, (resolv.h>, <arpa/nameser.h>. These files
 * are assumed to be present in the /usr/include directory.
 *
 * The resolver code depends on the definition of the BSD pre-processor
 * variable. This variable is usually defined in the file <sys/param.h>.
 *
 * The definition of this variable determines the method how to handle
 * datagram connections. This may not work properly on all platforms.
 *
 * The hostent struct defined in <netdb.h> is assumed to handle multiple
 * addresses in h_addr_list[]. Usually this is true if BSD >= 43.
 *
 * Your nameserver may not handle queries about top-level zones properly
 * if the "domain" directive is present in the named.boot file. It will
 * append the default domain to single names for which no data is cached.
 *
 * The treatment of TXT records has changed from 4.8.2 to 4.8.3. Formerly,
 * the data consisted simply of the text string. Now, the text string is
 * preceded by the character count with a maximum of 255, and multiple
 * strings are embedded if the total character count exceeds 255.
 * We handle only the new situation in this program, assuming that nobody
 * uses TXT records before 4.8.3 (unfortunately this is not always true:
 * current vendor supplied software may sometimes be even pre-BIND 4.8.2).
 *
 * Note that in 4.8.3 PACKETSZ from nameser.h is still at 512, which is
 * the maximum possible packet size for datagrams, whereas MAXDATA from
 * db.h has increased from 256 to 2048. The resolver defines MAXPACKET
 * as 1024. The nameserver reads queries in a buffer of size BUFSIZ.
 *
 * The gethostbyname() routine in 4.8.3 interprets dotted quads (if not
 * terminated with a dot) and simulates a gethostbyaddr(), but we will
 * not rely on it, and handle dotted quads ourselves.
 *
 * On some systems a bug in the _doprnt() routine exists which prevents
 * printf("%.*s", n, string) to be printed correctly if n == 0.
 *
 * This program has not been optimized for speed. Especially the memory
 * management is simple and straightforward.
 */

/*
 *            Terminology used
 *
 * Gateway hosts.
 * These are hosts that have more than one address registered under
 * the same name. Obviously we cannot recognize a gateway host if it
 * has different names associated with its different addresses.
 *
 * Duplicate hosts.
 * These are non-gateway hosts of which the address was found earlier
 * but with a different name, possibly in a totally different zone.
 * Such hosts should not be counted again in the overall host count.
 * This situation notably occurs in e.g. the "ac.uk" domain which has
 * many names registered in both the long and the abbreviated form,
 * such as 'host.department.university.ac.uk' and 'host.dept.un.ac.uk'.
 * This is probably not an error per se. It is an error if some domain
 * has registered a foreign address under a name within its own domain.
 * To recognize duplicate hosts when traversing many zones, we have to
 * maintain a global list of host addresses. To simplify things, only
 * single-address hosts are handled as such.
 *
 * Extrazone hosts.
 * These are hosts which belong to a zone but which are not residing
 * directly within the zone under consideration and which are not
 * glue records for a delegated zone of the given zone. E.g. if we are
 * processing the zone 'bar' and find 'host.foo.bar' but 'foo.bar' is not
 * an NS registered delegated zone of 'bar' then it is considered to be
 * an extrazone host. This is not necessarily an error, but it could be.
 *
 * Lame delegations.
 * If we query the SOA record of a zone at a supposedly authoritative
 * nameserver for that zone (listed in the NS records for the zone),
 * the SOA record should be present and the answer authoritative.
 * If not, we flag a lame delegation of the zone to that nameserver.
 * This may need refinement in some special cases.
 * A lame delegation is also flagged if we discover that a nameserver
 * mentioned in an NS record does not exist when looking up its address.
 *
 * Primary nameserver.
 * This utility assumes that the first domain name in the RHS of the
 * SOA record for a zone contains the name of the primary nameserver
 * (or one of the primary nameservers) for that zone. Unfortunately,
 * this field has not been unambiguously defined. Nevertheless, many
 * hostmasters interpret the definitions given in RFC 1033 and 1035
 * as such, and therefore host will continue doing so. Interpretation
 * as the machine that holds the zone data disk file is pretty useless.
 */

/*
 *        Usage: host [options] name [server]
 *        Usage: host [options] -x [name ...]
 *        Usage: host [options] -X server [name ...]
 *
 * Regular command line options:
 * ----------------------------
 *
 * -t type    specify query type; default is T_A for normal mode
 * -a        specify query type T_ANY
 * -v        print verbose messages (-vv is very verbose)
 * -d        print debugging output (-dd prints even more)
 *
 * Special mode options.
 * --------------------
 *
 * -l        special mode to generate zone listing for a zone
 * -L level    do recursive zone listing/checking this level deep
 * -p        use primary nameserver of zone for zone transfers
 * -P server    give priority to preferred servers for zone transfers
 * -N zone    do not perform zone transfer for these explicit zones
 * -S        print zone resource record statistics
 * -H        special mode to count hosts residing in a zone
 * -G        same as -H but lists gateway hosts in addition
 * -E        same as -H but lists extrazone hosts in addition
 * -D        same as -H but lists duplicate hosts in addition
 * -C        special mode to check SOA records for a zone
 * -A        special mode to check reverse mappings of host addresses
 *
 * Miscellaneous options.
 * ---------------------
 *
 * -f filename    log resource record output also in given file
 * -F filename    same as -f, but exchange role of stdout and log file
 * -I chars    chars are not considered illegal in domain names
 * -i        generate reverse in-addr.arpa query for dotted quad
 * -n        generate reverse nsap.int query for dotted nsap address
 * -q        be quiet about some non-fatal errors
 * -T        print ttl value during non-verbose output
 * -Z        print selected RR output in full zone file format
 *
 * Seldom used options.
 * -------------------
 *
 * -c class    specify query class; default is C_IN
 * -e        exclude info from names that do not reside in the zone
 * -m        specify query type T_MAILB and trace MB records
 * -o        suppress resource record output to stdout
 * -r        do not use recursion when querying nameserver
 * -R        repeatedly add search domains to qualify queryname
 * -s secs    specify timeout value in seconds; default is 2 * 5
 * -u        use virtual circuit instead of datagram for queries
 * -w        wait until nameserver becomes available
 *
 * Undocumented options. (Experimental, subject to change)
 * --------------------
 *
 * -g length    only select names that are at least this long
 * -B        enforce full BIND behavior during DNSRCH
 * -M        special mode to list mailable delegated zones of zone
 * -W        special mode to list wildcard records in a zone
 * -z        special mode to list delegated zones in a zone
 */

static char Usage[] =
"\
Usage:      host [-v] [-a] [-t querytype] [options]  name  [server]\n\
Listing:    host [-v] [-a] [-t querytype] [options]  -l zone  [server]\n\
Hostcount:  host [-v] [options] -H [-D] [-E] [-G] zone\n\
Check soa:  host [-v] [options] -C zone\n\
Addrcheck:  host [-v] [options] -A host\n\
Listing options: [-L level] [-S] [-A] [-p] [-P prefserver] [-N skipzone]\n\
Common options:  [-d] [-f|-F filename] [-I chars] [-i|-n] [-q] [-T] [-Z]\n\
Other options:   [-c class] [-e] [-m] [-o] [-r] [-R] [-s secs] [-u] [-w]\n\
Extended usage:  [-x [name ...]] [-X server [name ...]]\
";

#include <stdio.h>
#include <ctype.h>
#include <errno.h>
#include <netdb.h>
#include <time.h>

#include <sys/types.h>        /* not always automatically included */
#include <sys/param.h>
#include <sys/socket.h>
#include <netinet/in.h>

#undef NOERROR            /* in <sys/streams.h> on solaris 2.x */
#include <arpa/nameser.h>
#include <resolv.h>

#include "port.h"        /* various portability definitions */
#include "conf.h"        /* various configuration definitions */
#include "type.h"        /* types should be in <arpa/nameser.h> */
#include "exit.h"        /* exit codes come from <sysexits.h> */

typedef int    bool;        /* boolean type */
#define TRUE    1
#define FALSE    0

#ifndef NO_DATA
#define NO_DATA    NO_ADDRESS    /* used here only in case authoritative */
#endif

#define NO_RREC    (NO_DATA + 1)    /* used for non-authoritative NO_DATA */
#define NO_HOST    (NO_DATA + 2)    /* used for non-authoritative HOST_NOT_FOUND */

#define QUERY_REFUSED  (NO_DATA + 3)    /* query was refused by server */
#define SERVER_FAILURE (NO_DATA + 4)    /* instead of TRY_AGAIN upon SERVFAIL */
#define HOST_NOT_CANON (NO_DATA + 5)    /* host name is not canonical */

#define T_NONE    0        /* yet unspecified resource record type */
#define T_FIRST    T_A        /* first possible type in resource record */
#define T_LAST    (T_IXFR - 1)    /* last  possible type in resource record */

#ifndef NOCHANGE
#define NOCHANGE 0xf        /* compatibility with older BIND versions */
#endif

#define NOT_DOTTED_QUAD    ((ipaddr_t)-1)
#define BROADCAST_ADDR    ((ipaddr_t)0xffffffff)
#define LOCALHOST_ADDR    ((ipaddr_t)0x7f000001)

#if PACKETSZ > 8192
#define MAXPACKET PACKETSZ    /* PACKETSZ should be the max udp size (512) */
#else
#define MAXPACKET 8192        /* but tcp packets can be considerably larger */
#endif

typedef union {
    HEADER header;
    u_char packet[MAXPACKET];
} querybuf;

#ifndef HFIXEDSZ
#define HFIXEDSZ 12        /* actually sizeof(HEADER) */
#endif

#define MAXDLEN (MAXPACKET - HFIXEDSZ)    /* upper bound for dlen */

#include "rrec.h"        /* resource record structures */

#define input            /* read-only input parameter */
#define output            /* modified output parameter */

#define STDIN    0
#define STDOUT    1
#define STDERR    2

#ifdef lint
#define EXTERN
#else
#define EXTERN extern
#endif

EXTERN int errno;
EXTERN int h_errno;        /* defined in the resolver library */
EXTERN res_state_t _res;    /* defined in res_init.c */
extern char *dbprefix;        /* prefix for debug messages (send.c) */
extern char *version;        /* program version number (vers.c) */

char **optargv = NULL;        /* argument list including default options */
int optargc = 0;        /* number of arguments in new argument list */

int errorcount = 0;        /* global error count */

int record_stats[T_ANY+1];    /* count of resource records per type */

char cnamebuf[MAXDNAME+1];
char *cname = NULL;        /* RHS name to which CNAME is aliased */
char mnamebuf[MAXDNAME+1];
char *mname = NULL;        /* RHS name to which MR or MG is aliased */
char soanamebuf[MAXDNAME+1];
char *soaname = NULL;        /* LHS domain name of SOA record */
char subnamebuf[MAXDNAME+1];
char *subname = NULL;        /* LHS domain name of NS record */
char adrnamebuf[MAXDNAME+1];
char *adrname = NULL;        /* LHS domain name of A record */

ipaddr_t address;        /* internet address of A record */

char *listhost = NULL;        /* actual host queried during zone listing */

char serverbuf[MAXDNAME+1];
char *server = NULL;        /* name of explicit server to query */

char realnamebuf[2*MAXDNAME+2];
char *realname = NULL;        /* the actual name that was queried */

FILE *logfile = NULL;        /* default is stdout only */
bool logexchange = FALSE;    /* exchange role of log file and stdout */

char *illegal = NULL;        /* give warning about illegal domain names */
char *skipzone = NULL;        /* zone(s) for which to skip zone transfer */
char *prefserver = NULL;    /* preferred server(s) for zone listing */

char *queryname = NULL;        /* the name about which to query */
int querytype = T_NONE;        /* the type of the query */
int queryclass = C_IN;        /* the class of the query */
ipaddr_t queryaddr;        /* set if name to query is dotted quad */

int debug = 0;            /* print resolver debugging output */
int verbose = 0;        /* verbose mode for extra output */

#ifdef justfun
int namelen = 0;        /* select records exceeding this length */
#endif

int recursive = 0;        /* recursive listmode maximum level */
int recursion_level = 0;    /* current recursion level */
int skip_level = 0;        /* level beyond which to skip checks */
int print_level = 0;        /* level below which to skip verbose output */

bool quiet = FALSE;        /* suppress non-fatal warning messages */
bool reverse = FALSE;        /* generate reverse in-addr.arpa queries */
bool revnsap = FALSE;        /* generate reverse nsap.int queries */
bool primary = FALSE;        /* use primary server for zone transfers */
bool suppress = FALSE;        /* suppress resource record output */
bool dotprint = FALSE;        /* print trailing dot in non-listing mode */
bool ttlprint = FALSE;        /* print ttl value in non-verbose mode */
bool waitmode = FALSE;        /* wait until server becomes available */
bool mailmode = FALSE;        /* trace MG and MR into MB records */
bool addrmode = FALSE;        /* check reverse mappings of addresses */
bool listmode = FALSE;        /* generate zone listing of a zone */
bool hostmode = FALSE;        /* count real hosts residing within zone */
bool duplmode = FALSE;        /* list duplicate hosts within zone */
bool extrmode = FALSE;        /* list extrazone hosts within zone */
bool gatemode = FALSE;        /* list gateway hosts within zone */
bool checkmode = FALSE;        /* check SOA records at each nameserver */
bool mxdomains = FALSE;        /* list MX records for each delegated zone */
bool wildcards = FALSE;        /* list only wildcard records in a zone */
bool listzones = FALSE;        /* list only delegated zones in a zone */
bool exclusive = FALSE;        /* exclude records that are not in zone */
bool recurskip = FALSE;        /* skip certain checks during recursion */
bool statistics = FALSE;    /* print resource record statistics */
bool bindcompat = FALSE;    /* enforce full BIND DNSRCH compatibility */
bool classprint = FALSE;    /* print class value in non-verbose mode */

#include "defs.h"        /* declaration of functions */

#define is_xdigit(c)    (isascii(c) && isxdigit(c))
#define is_space(c)    (isascii(c) && isspace(c))
#define is_alnum(c)    (isascii(c) && isalnum(c))
#define is_upper(c)    (isascii(c) && isupper(c))

#define lowercase(c)    (is_upper(c) ? tolower(c) : (c))
#define lower(c)    (((c) >= 'A' && (c) <= 'Z') ? (c) + 'a' - 'A' : (c))
#define hexdigit(n)    (((n) < 10) ? '0' + (n) : 'A' + (n) - 10);

#define bitset(a,b)    (((a) & (b)) != 0)
#define sameword(a,b)    (strcasecmp(a,b) == 0)
#define samepart(a,b)    (strncasecmp(a,b,strlen(b)) == 0)
#define samehead(a,b)    (strncasecmp(a,b,sizeof(b)-1) == 0)

#define fakename(a)    (samehead(a,"localhost.") || samehead(a,"loopback."))
#define nulladdr(a)    (((a) == 0) || ((a) == BROADCAST_ADDR))
#define fakeaddr(a)    (nulladdr(a) || ((a) == htonl(LOCALHOST_ADDR)))
#define incopy(a)    *((struct in_addr *)(a))
#define querysize(n)    (((n) > sizeof(querybuf)) ? sizeof(querybuf) : (n))

#define newlist(a,n,t)    (t *)xalloc((ptr_t *)(a), (siz_t)((n)*sizeof(t)))
#define newstruct(t)    (t *)xalloc((ptr_t *)NULL, (siz_t)(sizeof(t)))
#define newstring(s)    (char *)xalloc((ptr_t *)NULL, (siz_t)(strlen(s)+1))
#define newstr(s)    strcpy(newstring(s), s)
#define xfree(a)    (void) free((ptr_t *)(a))

#define strlength(s)    (int)strlen(s)
#define in_string(s,c)    (index(s,c) != NULL)
#define is_quoted(a,b)    (((a) > (b)) && ((a)[-1] == '\\'))

#define plural(n)    (((n) == 1) ? "" : "s")
#define plurale(n)    (((n) == 1) ? "" : "es")

#ifdef DEBUG
#define assert(condition)\
{\
    if (!(condition))\
    {\
        (void) fprintf(stderr, "assertion botch: ");\
        (void) fprintf(stderr, "%s(%d): ", __FILE__, __LINE__);\
        (void) fprintf(stderr, "%s\n", "condition");\
        exit(EX_SOFTWARE);\
    }\
}
#else
#define assert(condition)
#endif

/*
** MAIN -- Start of program host
** -----------------------------
**
**    Exits:
**        EX_SUCCESS    Operation successfully completed
**        EX_UNAVAILABLE    Could not obtain requested information
**        EX_CANTCREAT    Could not create specified log file
**        EX_NOINPUT    No input arguments were found
**        EX_NOHOST    Could not lookup explicit server
**        EX_OSERR    Could not obtain resources
**        EX_USAGE    Improper parameter/option specified
**        EX_SOFTWARE    Assertion botch in DEBUG mode
*/

int
main(argc, argv)
input int argc;
input char *argv[];
{
    register char *option;
    res_state_t new_res;        /* new resolver database */
    int result;            /* result status of action taken */
    char *program;            /* name that host was called with */
    char *servername = NULL;    /* name of explicit server */
    char *logfilename = NULL;    /* name of log file */
    bool extended = FALSE;        /* accept extended argument syntax */

    assert(sizeof(int) >= 4);    /* probably paranoid */
#ifdef obsolete
    assert(sizeof(u_short) == 2);    /* perhaps less paranoid */
    assert(sizeof(ipaddr_t) == 4);    /* but this is critical */
#endif

/*
 * Synchronize stdout and stderr in case output is redirected.
 */
    linebufmode(stdout);

/*
 * Initialize resolver, set new defaults. See show_res() for details.
 * The old defaults are (RES_RECURSE | RES_DEFNAMES | RES_DNSRCH)
 */
    (void) res_init();

    _res.options |=  RES_DEFNAMES;    /* qualify single names */
    _res.options &= ~RES_DNSRCH;    /* dotted names are qualified */

    _res.options |=  RES_RECURSE;    /* request nameserver recursion */
    _res.options &= ~RES_DEBUG;    /* turn off debug printout */
    _res.options &= ~RES_USEVC;    /* do not use virtual circuit */

    _res.retry = DEF_RETRIES;    /* number of datagram retries */
    _res.retrans = DEF_RETRANS;    /* timeout in secs between retries */

    /* initialize packet id */
    _res.id = getpid() & 0x7fff;

    /* save new defaults */
    new_res = _res;

/*
 * Check whether host was called with a different name.
 * Interpolate default options and parameters.
 */
    if (argc < 1 || argv[0] == NULL)
        fatal(Usage);

    option = getenv("HOST_DEFAULTS");
    if (option != NULL)
    {
        set_defaults(option, argc, argv);
        argc = optargc; argv = optargv;
    }

    program = rindex(argv[0], '/');
    if (program++ == NULL)
        program = argv[0];

    /* check for resource record names */
    querytype = parse_type(program);
    if (querytype < 0)
        querytype = T_NONE;

    /* check for zone listing abbreviation */
    if (sameword(program, "zone"))
        listmode = TRUE;

/*
 * Scan command line options and flags.
 */
    while (argc > 1 && argv[1] != NULL && argv[1][0] == '-')
    {
        for (option = &argv[1][1]; *option != '\0'; option++)
        {
        switch (*option)
        {
            case 'w' :
            waitmode = TRUE;
            new_res.retry = DEF_RETRIES;
            new_res.retrans = DEF_RETRANS;
            break;

            case 's' :
            if (argv[2] == NULL || argv[2][0] == '-')
                fatal("Missing timeout value");
            new_res.retry = DEF_RETRIES;
            new_res.retrans = atoi(argv[2]);
            if (new_res.retrans <= 0)
                fatal("Invalid timeout value %s", argv[2]);
            argv++; argc--;
            break;

            case 'r' :
            new_res.options &= ~RES_RECURSE;
            break;

            case 'B' :
            bindcompat = TRUE;
            /*FALLTHROUGH*/

            case 'R' :
            new_res.options |= RES_DNSRCH;
            break;

            case 'u' :
            new_res.options |= RES_USEVC;
            break;

            case 'd' :
            new_res.options |= RES_DEBUG;
            debug++;        /* increment debugging level */
            break;

            case 'v' :
            verbose++;        /* increment verbosity level */
            break;

            case 'q' :
            quiet = TRUE;
            break;

            case 'i' :
            reverse = TRUE;
            break;

            case 'n' :
            revnsap = TRUE;
            break;

            case 'p' :
            primary = TRUE;
            break;

            case 'o' :
            suppress = TRUE;
            break;

            case 'e' :
            exclusive = TRUE;
            break;

            case 'S' :
            statistics = TRUE;
            break;

            case 'T' :
            ttlprint = TRUE;
            break;

            case 'Z' :
            dotprint = TRUE;
            ttlprint = TRUE;
            classprint = TRUE;
            break;

            case 'A' :
            addrmode = TRUE;
            break;

            case 'D' :
            case 'E' :
            case 'G' :
            case 'H' :
            if (*option == 'D')
                duplmode = TRUE;
            if (*option == 'E')
                extrmode = TRUE;
            if (*option == 'G')
                gatemode = TRUE;
            hostmode = TRUE;
            listmode = TRUE;
            if (querytype == T_NONE)
                querytype = -1;    /* suppress zone data output */
            break;

            case 'C' :
            checkmode = TRUE;
            listmode = TRUE;
            if (querytype == T_NONE)
                querytype = -1;    /* suppress zone data output */
            break;

            case 'z' :
            listzones = TRUE;
            listmode = TRUE;
            if (querytype == T_NONE)
                querytype = -1;    /* suppress zone data output */
            break;

            case 'M' :
            mxdomains = TRUE;
            listmode = TRUE;
            if (querytype == T_NONE)
                querytype = -1;    /* suppress zone data output */
            break;

            case 'W' :
            wildcards = TRUE;
            listmode = TRUE;
            if (querytype == T_NONE)
                querytype = T_MX;
            break;

            case 'L' :
            if (argv[2] == NULL || argv[2][0] == '-')
                fatal("Missing recursion level");
            recursive = atoi(argv[2]);
            if (recursive <= 0)
                fatal("Invalid recursion level %s", argv[2]);
            argv++; argc--;
            /*FALLTHROUGH*/

            case 'l' :
            listmode = TRUE;
            break;

            case 'c' :
            if (argv[2] == NULL || argv[2][0] == '-')
                fatal("Missing query class");
            queryclass = parse_class(argv[2]);
            if (queryclass < 0)
                fatal("Invalid query class %s", argv[2]);
            argv++; argc--;
            break;

            case 't' :
            if (argv[2] == NULL || argv[2][0] == '-')
                fatal("Missing query type");
            querytype = parse_type(argv[2]);
            if (querytype < 0)
                fatal("Invalid query type %s", argv[2]);
            argv++; argc--;
            break;

            case 'a' :
            querytype = T_ANY;    /* filter anything available */
            break;

            case 'm' :
            mailmode = TRUE;
            querytype = T_MAILB;    /* filter MINFO/MG/MR/MB data */
            break;

            case 'I' :
            if (argv[2] == NULL || argv[2][0] == '-')
                fatal("Missing allowed chars");
            illegal = argv[2];
            argv++; argc--;
            break;

            case 'P' :
            if (argv[2] == NULL || argv[2][0] == '-')
                fatal("Missing preferred server");
            prefserver = argv[2];
            argv++; argc--;
            break;

            case 'N' :
            if (argv[2] == NULL || argv[2][0] == '-')
                fatal("Missing zone to be skipped");
            skipzone = argv[2];
            argv++; argc--;
            break;

            case 'F' :
            logexchange = TRUE;
            /*FALLTHROUGH*/

            case 'f' :
            if (argv[2] == NULL || argv[2][0] == '-')
                fatal("Missing log file name");
            logfilename = argv[2];
            argv++; argc--;
            break;

            case 'X' :
            if (argv[2] == NULL || argv[2][0] == '-')
                fatal("Missing server name");
            servername = argv[2];
            argv++; argc--;
            /*FALLTHROUGH*/

            case 'x' :
            extended = TRUE;
            break;
#ifdef justfun
            case 'g' :
            if (argv[2] == NULL || argv[2][0] == '-')
                fatal("Missing minimum length");
            namelen = atoi(argv[2]);
            if (namelen <= 0)
                fatal("Invalid minimum length %s", argv[2]);
            argv++; argc--;
            break;
#endif
            case 'V' :
            printf("Version %s\n", version);
            exit(EX_SUCCESS);

            default:
            fatal(Usage);
        }
        }

        argv++; argc--;
    }

/*
 * Check the remaining arguments.
 */
    /* old syntax must have at least one argument */
    if (!extended && (argc < 2 || argv[1] == NULL || argc > 3))
        fatal(Usage);

    /* old syntax has explicit server as second argument */
    if (!extended && (argc > 2 && argv[2] != NULL))
        servername = argv[2];

/*
 * Open log file if requested.
 */
    if (logfilename != NULL)
        set_logfile(logfilename);

/*
 * Set default preferred server for zone listings, if not specified.
 */
    if (listmode && (prefserver == NULL))
        prefserver = myhostname();

/*
 * Check for possible alternative server. Use new resolver defaults.
 */
    if (servername != NULL)
        set_server(servername);

/*
 * Do final resolver initialization.
 * Show resolver parameters and special environment options.
 */
    /* set new resolver values changed by command options */
    _res.retry = new_res.retry;
    _res.retrans = new_res.retrans;
    _res.options = new_res.options;

    /* show the new resolver database */
    if (verbose > 1 || debug > 1)
        show_res();

    /* show customized default domain */
    option = getenv("LOCALDOMAIN");
    if (option != NULL && verbose > 1)
        printf("Explicit local domain %s\n\n", option);

/*
 * Process command line argument(s) depending on syntax.
 */
    if (!extended) /* only one argument */
        result = process_name(argv[1]);

    else if (argc < 2) /* no arguments */
        result = process_file(stdin);

    else /* multiple command line arguments */
        result = process_argv(argc, argv);

/*
 * Report result status of action taken.
 */
    exit(result);
    /*NOTREACHED*/
}

/*
** SET_DEFAULTS -- Interpolate default options and parameters in argv
** ------------------------------------------------------------------
**
**    The HOST_DEFAULTS environment variable gives customized options.
**
**    Returns:
**        None.
**
**    Outputs:
**        Creates ``optargv'' vector with ``optargc'' arguments.
*/

void
set_defaults(option, argc, argv)
input char *option;            /* option string */
input int argc;                /* original command line arg count */
input char *argv[];            /* original command line arguments */
{
    register char *p, *q;
    register int i;

/*
 * Allocate new argument vector.
 */
    optargv = newlist(NULL, 2, char *);
    optargv[0] = argv[0];
    optargc = 1;

/*
 * Construct argument list from option string.
 */
    for (q = "", p = newstr(option); *p != '\0'; p = q)
    {
        while (is_space(*p))
            p++;

        if (*p == '\0')
            break;

        for (q = p; *q != '\0' && !is_space(*q); q++)
            continue;

        if (*q != '\0')
            *q++ = '\0';

        optargv = newlist(optargv, optargc+2, char *);
        optargv[optargc] = p;
        optargc++;
    }

/*
 * Append command line arguments.
 */
    for (i = 1; i < argc && argv[i] != NULL; i++)
    {
        optargv = newlist(optargv, optargc+2, char *);
        optargv[optargc] = argv[i];
        optargc++;
    }

    /* and terminate */
    optargv[optargc] = NULL;
}

/*
** PROCESS_ARGV -- Process command line arguments
** ----------------------------------------------
**
**    Returns:
**        EX_SUCCESS if information was obtained successfully.
**        Appropriate exit code otherwise.
*/

int
process_argv(argc, argv)
input int argc;
input char *argv[];
{
    register int i;
    int result;            /* result status of action taken */
    int excode = EX_NOINPUT;    /* overall result status */

    for (i = 1; i < argc && argv[i] != NULL; i++)
    {
        /* process a single argument */
        result = process_name(argv[i]);

        /* maintain overall result */
        if (result != EX_SUCCESS || excode == EX_NOINPUT)
            excode = result;
    }

    /* return overall result */
    return(excode);
}

/*
** PROCESS_FILE -- Process arguments from input file
** -------------------------------------------------
**
**    Returns:
**        EX_SUCCESS if information was obtained successfully.
**        Appropriate exit code otherwise.
*/

int
process_file(fp)
input FILE *fp;                /* input file with query names */
{
    register char *p, *q;
    char buf[BUFSIZ];
    int result;            /* result status of action taken */
    int excode = EX_NOINPUT;    /* overall result status */

    while (fgets(buf, sizeof(buf), fp) != NULL)
    {
        p = index(buf, '\n');
        if (p != NULL)
            *p = '\0';

        /* extract names separated by whitespace */
        for (q = "", p = buf; *p != '\0'; p = q)
        {
            while (is_space(*p))
                p++;

            /* ignore comment lines */
            if (*p == '\0' || *p == '#' || *p == ';')
                break;

            for (q = p; *q != '\0' && !is_space(*q); q++)
                continue;

            if (*q != '\0')
                *q++ = '\0';

            /* process a single argument */
            result = process_name(p);

            /* maintain overall result */
            if (result != EX_SUCCESS || excode == EX_NOINPUT)
                excode = result;
        }
    }

    /* return overall result */
    return(excode);
}

/*
** PROCESS_NAME -- Process a single command line argument
** ------------------------------------------------------
**
**    Returns:
**        EX_SUCCESS if information was obtained successfully.
**        Appropriate exit code otherwise.
**
**    Wrapper for execute_name() to hide administrative tasks.
*/

int
process_name(name)
input char *name;            /* command line argument */
{
    int result;            /* result status of action taken */
    static int save_querytype;
    static bool save_reverse;
    static bool firstname = TRUE;

    /* separate subsequent pieces of output */
    if (!firstname && (verbose || debug || checkmode))
        printf("\n");

/*
 * Some global variables are redefined further on. Save their initial
 * values in the first pass, and restore them during subsequent passes.
 */
    if (firstname)
    {
        save_querytype = querytype;
        save_reverse = reverse;
        firstname = FALSE;
    }
    else
    {
        querytype = save_querytype;
        reverse = save_reverse;
    }

/*
 * Do the real work.
 */
    result = execute_name(name);
    return(result);
}

/*
** EXECUTE_NAME -- Process a single command line argument
** ------------------------------------------------------
**
**    Returns:
**        EX_SUCCESS if information was obtained successfully.
**        Appropriate exit code otherwise.
**
**    Outputs:
**        Defines ``queryname'' and ``queryaddr'' appropriately.
**
**    Side effects:
**        May redefine ``querytype'' and ``reverse'' if necessary.
*/

int
execute_name(name)
input char *name;            /* command line argument */
{
    bool result;            /* result status of action taken */

    /* check for nonsense input name */
    if (strlength(name) > MAXDNAME)
    {
        errmsg("Query name %s too long", name);
        return(EX_USAGE);
    }

/*
 * Analyze the name and type to be queried about.
 * The name can be an ordinary domain name, or an internet address
 * in dotted quad notation. If the -n option is given, the name is
 * supposed to be a dotted nsap address.
 * Furthermore, an empty input name is treated as the root domain.
 */
    queryname = name;
    if (queryname[0] == '\0')
        queryname = ".";

    if (sameword(queryname, "."))
        queryaddr = NOT_DOTTED_QUAD;
    else
        queryaddr = inet_addr(queryname);

/*
 * Generate reverse in-addr.arpa query if so requested.
 * The input name must be a dotted quad, and be convertible.
 */
    if (reverse)
    {
        if (queryaddr == NOT_DOTTED_QUAD)
            name = NULL;
        else
            name = in_addr_arpa(queryname);

        if (name == NULL)
        {
            errmsg("Invalid dotted quad %s", queryname);
            return(EX_USAGE);
        }

        /* redefine appropriately */
        queryname = name;
        queryaddr = NOT_DOTTED_QUAD;
    }

/*
 * Generate reverse nsap.int query if so requested.
 * The input name must be a dotted nsap, and be convertible.
 */
    if (revnsap)
    {
        if (reverse)
            name = NULL;
        else
            name = nsap_int(queryname);

        if (name == NULL)
        {
            errmsg("Invalid nsap address %s", queryname);
            return(EX_USAGE);
        }

        /* redefine appropriately */
        queryname = name;
        queryaddr = NOT_DOTTED_QUAD;

        /* this is also a reversed mapping domain */
        reverse = TRUE;
    }

/*
 * In regular mode, the querytype is used to formulate the nameserver
 * query, and any response is filtered out when processing the answer.
 * In listmode, the querytype is used to filter out the proper records.
 */
    /* set querytype for regular mode if unspecified */
    if ((querytype == T_NONE) && !listmode)
    {
        if ((queryaddr != NOT_DOTTED_QUAD) || reverse)
            querytype = T_PTR;
        else
            querytype = T_A;
    }

/*
 * Check for incompatible options.
 */
    /* cannot have dotted quad in listmode */
    if (listmode && (queryaddr != NOT_DOTTED_QUAD))
    {
        errmsg("Invalid query name %s", queryname);
        return(EX_USAGE);
    }

    /* must have regular name or dotted quad in addrmode */
    if (!listmode && addrmode && reverse)
    {
        errmsg("Invalid query name %s", queryname);
        return(EX_USAGE);
    }

    /* show what we are going to query about */
    if (verbose)
        show_types(queryname, querytype, queryclass);

/*
 * All set. Perform requested function.
 */
    result = execute(queryname, queryaddr);
    return(result ? EX_SUCCESS : EX_UNAVAILABLE);
}

/*
** EXECUTE -- Perform the requested function
** -----------------------------------------
**
**    Returns:
**        TRUE if information was obtained successfully.
**        FALSE otherwise.
**
**    The whole environment has been set up and checked.
*/

bool
execute(name, addr)
input char *name;            /* name to query about */
input ipaddr_t addr;            /* explicit address of query */
{
    bool result;            /* result status of action taken */

/*
 * Special mode to list contents of specified zone.
 */
    if (listmode)
    {
        result = list_zone(name);
        return(result);
    }

/*
 * Special mode to check reverse mappings of host addresses.
 */
    if (addrmode)
    {
        if (addr == NOT_DOTTED_QUAD)
            result = check_addr(name);
        else
            result = check_name(addr);
        return(result);
    }

/*
 * Regular mode to query about specified host.
 */
    result = host_query(name, addr);
    return(result);
}

/*
** HOST_QUERY -- Regular mode to query about specified host
** --------------------------------------------------------
**
**    Returns:
**        TRUE if information was obtained successfully.
**        FALSE otherwise.
*/

bool
host_query(name, addr)
input char *name;            /* name to query about */
input ipaddr_t addr;            /* explicit address of query */
{
    struct hostent *hp;
    struct in_addr inaddr;
    char newnamebuf[MAXDNAME+1];
    char *newname = NULL;        /* name to which CNAME is aliased */
    int ncnames = 0;        /* count of CNAMEs in chain */
    bool result;            /* result status of action taken */

    inaddr.s_addr = addr;

    result = FALSE;
    h_errno = TRY_AGAIN;

    /* retry until positive result or permanent failure */
    while (result == FALSE && h_errno == TRY_AGAIN)
    {
        /* reset before each query to avoid stale data */
        errno = 0;
        realname = NULL;

        if (addr == NOT_DOTTED_QUAD)
        {
            /* reset CNAME indicator */
            cname = NULL;

            /* lookup the name in question */
            if (newname == NULL)
                result = get_hostinfo(name, FALSE);
            else
                result = get_hostinfo(newname, TRUE);

            /* recurse on CNAMEs, but not too deep */
            if (cname && (querytype != T_CNAME))
            {
                newname = strcpy(newnamebuf, cname);

                if (ncnames++ > MAXCHAIN)
                {
                    errmsg("Possible CNAME loop");
                    return(FALSE);
                }

                result = FALSE;
                h_errno = TRY_AGAIN;
                continue;
            }
        }
        else
        {
            hp = geth_byaddr((char *)&inaddr, INADDRSZ, AF_INET);
            if (hp != NULL)
            {
                print_host("Name", hp);
                result = TRUE;
            }
        }

        /* only retry if so requested */
        if (!waitmode)
            break;
    }

    /* use actual name if available */
    if (realname != NULL)
        name = realname;

    /* explain the reason of a failure */
    if (result == FALSE)
        ns_error(name, querytype, queryclass, server);

    return(result);
}

/*
** MYHOSTNAME -- Determine our own fully qualified host name
** ---------------------------------------------------------
**
**    Returns:
**        Pointer to own host name.
**        Aborts if host name could not be determined.
*/

char *
myhostname()
{
    struct hostent *hp;
    static char mynamebuf[MAXDNAME+1];
    static char *myname = NULL;

    if (myname == NULL)
    {
        if (gethostname(mynamebuf, MAXDNAME) < 0)
        {
            perror("gethostname");
            exit(EX_OSERR);
        }
        mynamebuf[MAXDNAME] = '\0';

        hp = gethostbyname(mynamebuf);
        if (hp == NULL)
        {
            ns_error(mynamebuf, T_A, C_IN, server);
            errmsg("Error in looking up own name");
            exit(EX_NOHOST);
        }

        /* cache the result */
        myname = strncpy(mynamebuf, hp->h_name, MAXDNAME);
        myname[MAXDNAME] = '\0';
    }

    return(myname);
}

/*
** SET_SERVER -- Override default nameserver with explicit server
** --------------------------------------------------------------
**
**    Returns:
**        None.
**        Aborts the program if an unknown host was given.
**
**    Side effects:
**        The global variable ``server'' is set to indicate
**        that an explicit server is being used.
**
**    The default nameserver addresses in the resolver database
**    which are initialized by res_init() from /etc/resolv.conf
**    are replaced with the (possibly multiple) addresses of an
**    explicitly named server host. If a dotted quad is given,
**    only that single address will be used.
**
**    The answers from such server must be interpreted with some
**    care if we don't know beforehand whether it can be trusted.
*/

void
set_server(name)
input char *name;            /* name of server to be queried */
{
    register int i;
    struct hostent *hp;
    struct in_addr inaddr;
    ipaddr_t addr;            /* explicit address of server */

    /* check for nonsense input name */
    if (strlength(name) > MAXDNAME)
    {
        errmsg("Server name %s too long", name);
        exit(EX_USAGE);
    }

/*
 * Overrule the default nameserver addresses.
 */
    addr = inet_addr(name);
    inaddr.s_addr = addr;

    if (addr == NOT_DOTTED_QUAD)
    {
        /* lookup all of its addresses; this must not fail */
        hp = gethostbyname(name);
        if (hp == NULL)
        {
            ns_error(name, T_A, C_IN, server);
            errmsg("Error in looking up server name");
            exit(EX_NOHOST);
        }

        for (i = 0; i < MAXNS && hp->h_addr_list[i]; i++)
        {
            nslist(i).sin_family = AF_INET;
            nslist(i).sin_port = htons(NAMESERVER_PORT);
            nslist(i).sin_addr = incopy(hp->h_addr_list[i]);
        }
        _res.nscount = i;
    }
    else
    {
        /* lookup the name, but use only the given address */
        hp = gethostbyaddr((char *)&inaddr, INADDRSZ, AF_INET);

        nslist(0).sin_family = AF_INET;
        nslist(0).sin_port = htons(NAMESERVER_PORT);
        nslist(0).sin_addr = inaddr;
        _res.nscount = 1;
    }

/*
 * Indicate the use of an explicit server.
 */
    if (hp != NULL)
    {
        server = strncpy(serverbuf, hp->h_name, MAXDNAME);
        server[MAXDNAME] = '\0';

        if (verbose)
            print_host("Server", hp);
    }
    else
    {
        server = strcpy(serverbuf, inet_ntoa(inaddr));

        if (verbose)
            printf("Server: %s\n\n", server);
    }
}

/*
** SET_LOGFILE -- Initialize optional log file
** -------------------------------------------
**
**    Returns:
**        None.
**        Aborts the program if the file could not be created.
**
**    Side effects:
**        The global variable ``logfile'' is set to indicate
**        that resource record output is to be written to it.
**
**    Swap ordinary stdout and log file output if so requested.
*/

void
set_logfile(filename)
input char *filename;            /* name of log file */
{
    if (logexchange)
    {
        logfile = fdopen(dup(STDOUT), "w");
        if (logfile == NULL)
        {
            perror("fdopen");
            exit(EX_OSERR);
        }

        if (freopen(filename, "w", stdout) == NULL)
        {
            perror(filename);
            exit(EX_CANTCREAT);
        }
    }
    else
    {
        logfile = fopen(filename, "w");
        if (logfile == NULL)
        {
            perror(filename);
            exit(EX_CANTCREAT);
        }
    }
}

/*
** FATAL -- Abort program when illegal option encountered
** ------------------------------------------------------
**
**    Returns:
**        Aborts after issuing error message.
*/

void /*VARARGS1*/
fatal(fmt, a, b, c, d)
input char *fmt;            /* format of message */
input char *a, *b, *c, *d;        /* optional arguments */
{
    (void) fprintf(stderr, fmt, a, b, c, d);
    (void) fprintf(stderr, "\n");
    exit(EX_USAGE);
}


/*
** ERRMSG -- Issue error message to error output
** ---------------------------------------------
**
**    Returns:
**        None.
**
**    Side effects:
**        Increments the global error count.
*/

void /*VARARGS1*/
errmsg(fmt, a, b, c, d)
input char *fmt;            /* format of message */
input char *a, *b, *c, *d;        /* optional arguments */
{
    (void) fprintf(stderr, fmt, a, b, c, d);
    (void) fprintf(stderr, "\n");

    /* flag an error */
    errorcount++;
}

/*
** GET_HOSTINFO -- Principal routine to query about given name
** -----------------------------------------------------------
**
**    Returns:
**        TRUE if requested info was obtained successfully.
**        FALSE otherwise.
**
**    This is the equivalent of the resolver module res_search().
**
**    In this program RES_DEFNAMES is always on, and RES_DNSRCH
**    is off by default. This means that single names without dot
**    are always, and only, tried within the own default domain,
**    and compound names are assumed to be already fully qualified.
**
**    The default BIND behavior can be simulated by turning on
**    RES_DNSRCH with -R. The given name, whether or not compound,
**    is then    first tried within the possible search domains.
**
**    Note. In the latter case, the search terminates in case the
**    specified name exists but does not have the desired type.
**    The BIND behavior is to continue the search. This can be
**    simulated with the undocumented option -B.
*/

bool
get_hostinfo(name, qualified)
input char *name;            /* name to query about */
input bool qualified;            /* assume fully qualified if set */
{
    register char **domain;
    register char *cp;
    int dot;            /* number of dots in query name */
    bool result;            /* result status of action taken */
    char oldnamebuf[2*MAXDNAME+2];
    char *oldname;            /* saved actual name when NO_DATA */
    int nodata = 0;            /* NO_DATA status during DNSRCH */
    int nquery = 0;            /* number of extra search queries */

/*
 * Single dot means root zone.
 */
    if (sameword(name, "."))
        qualified = TRUE;

/*
 * Names known to be fully qualified are just tried ``as is''.
 */
    if (qualified)
    {
        result = get_domaininfo(name, (char *)NULL);
        return(result);
    }

/*
 * Count number of dots. Move to the end of the name.
 */
    for (dot = 0, cp = name; *cp != '\0'; cp++)
        if (*cp == '.')
            dot++;

/*
 * Check for aliases of single name.
 * Note that the alias is supposed to be fully qualified.
 */
    if (dot == 0 && (cp = hostalias(name)) != NULL)
    {
        if (verbose)
            printf("Aliased %s to %s\n", name, cp);

        result = get_domaininfo(cp, (char *)NULL);
        return(result);
    }

/*
 * Trailing dot means absolute (fully qualified) address.
 */
    if (dot != 0 && cp[-1] == '.')
    {
        cp[-1] = '\0';
        result = get_domaininfo(name, (char *)NULL);
        cp[-1] = '.';
        return(result);
    }

/*
 * Append own default domain and other search domains if appropriate.
 */
    if ((dot == 0 && bitset(RES_DEFNAMES, _res.options)) ||
        (dot != 0 && bitset(RES_DNSRCH, _res.options)))
    {
        for (domain = _res.dnsrch; *domain; domain++)
        {
            result = get_domaininfo(name, *domain);
            if (result)
                return(result);

            /* keep count of extra search queries */
            nquery++;

            /* in case nameserver not present */
            if (errno == ECONNREFUSED)
                return(FALSE);

            /* if no further search desired (single name) */
                if (!bitset(RES_DNSRCH, _res.options))
                break;

            /* if name exists but has not requested type */
            if (h_errno == NO_DATA || h_errno == NO_RREC)
            {
                if (bindcompat)
                {
                    /* remember status and search up */
                    oldname = strcpy(oldnamebuf, realname);
                    nodata = h_errno;
                    continue;
                }

                return(FALSE);
            }

            /* retry only if name does not exist at all */
            if (h_errno != HOST_NOT_FOUND && h_errno != NO_HOST)
                break;
        }
    }

/*
 * Single name lookup failed.
 */
    if (dot == 0)
    {
        /* unclear what actual name should be */
        if (nquery != 1)
            realname = NULL;

        /* restore nodata status from search */
        if (bindcompat && nodata)
        {
            realname = strcpy(realnamebuf, oldname);
            h_errno = nodata;
        }

        /* set status in case we never queried */
        if (!bitset(RES_DEFNAMES, _res.options))
            h_errno = HOST_NOT_FOUND;

        return(FALSE);
    }

/*
 * Rest means fully qualified.
 */
    result = get_domaininfo(name, (char *)NULL);

    /* restore nodata status from search */
    if (!result && bindcompat && nodata)
    {
        realname = strcpy(realnamebuf, oldname);
        h_errno = nodata;
    }

    return(result);
}

/*
** GET_DOMAININFO -- Fetch and print desired info about name in domain
** -------------------------------------------------------------------
**
**    Returns:
**        TRUE if requested info was obtained successfully.
**        FALSE otherwise.
**
**    Side effects:
**        Sets global variable ``realname'' to actual name queried.
**
**    This is the equivalent of the resolver module res_querydomain().
**
**    Things get a little complicated in case RES_DNSRCH is on.
**    If we get an answer but the data is corrupted, an error will be
**    returned and NO_RECOVERY will be set. This will terminate the
**    extra search loop, but a compound name will still be tried as-is.
**    The same holds if the query times out or we have a server failure,
**    in which case an error will be returned and TRY_AGAIN will be set.
**    For now we take this for granted. Normally RES_DNSRCH is disabled.
**    In this default case we do only one query and we have no problem.
*/

bool
get_domaininfo(name, domain)
input char *name;            /* name to query about */
input char *domain;            /* domain to which name is relative */
{
    char namebuf[2*MAXDNAME+2];    /* buffer to store full domain name */
    querybuf answer;
    register int n;
    bool result;            /* result status of action taken */

/*
 * Show what we are about to query.
 */
    if (verbose)
    {
        if (domain == NULL || domain[0] == '\0')
            printf("Trying %s", name);
        else
            printf("Trying %s within %s", name, domain);

        if (server && (verbose > 1))
            printf(" at server %s", server);

        printf(" ...\n");
    }

/*
 * Construct the actual domain name.
 * A null domain means the given name is already fully qualified.
 * If the composite name is too long, res_mkquery() will fail.
 */
    if (domain == NULL || domain[0] == '\0')
        (void) sprintf(namebuf, "%.*s", MAXDNAME, name);
    else
        (void) sprintf(namebuf, "%.*s.%.*s",
                MAXDNAME, name, MAXDNAME, domain);
    name = namebuf;

/*
 * Fetch the desired info.
 */
    n = get_info(&answer, name, querytype, queryclass);
    result = (n < 0) ? FALSE : TRUE;

/*
 * Print the relevant data.
 * If we got a positive answer, the data may still be corrupted.
 */
    if (result)
        result = print_info(&answer, n, name, querytype, queryclass, TRUE);

/*
 * Remember the actual name that was queried.
 * Must be at the end to avoid clobbering during recursive calls.
 */
    realname = strcpy(realnamebuf, name);

    return(result);
}

/*
** GET_INFO -- Basic routine to issue a nameserver query
** -----------------------------------------------------
**
**    Returns:
**        Length of nameserver answer buffer, if obtained.
**        -1 if an error occurred (h_errno is set appropriately).
**
**    This is the equivalent of the resolver module res_query().
*/

int
get_info(answerbuf, name, type, class)
output querybuf *answerbuf;        /* location of buffer to store answer */
input char *name;            /* full name to query about */
input int type;                /* specific resource record type */
input int class;            /* specific resource record class */
{
    querybuf query;
    HEADER *bp;
    int ancount;
    register int n;

/*
 * Construct query, and send it to the nameserver.
 * res_send() will fail if no nameserver responded. In the BIND version the
 * possible values for errno are ECONNREFUSED and ETIMEDOUT. If we did get
 * an answer, errno should be reset, since res_send() may have left an errno
 * in case it has used datagrams. Our private version of res_send() will leave
 * also other error statuses, and will clear errno if an answer was obtained.
 */
    errno = 0;    /* reset before querying nameserver */

    n = res_mkquery(QUERY, name, class, type, (qbuf_t *)NULL, 0,
            (rrec_t *)NULL, (qbuf_t *)&query, sizeof(querybuf));
    if (n < 0)
    {
        if (debug)
            printf("%sres_mkquery failed\n", dbprefix);
        h_errno = NO_RECOVERY;
        return(-1);
    }

    n = res_send((qbuf_t *)&query, n, (qbuf_t *)answerbuf, sizeof(querybuf));
    if (n < 0)
    {
        if (debug)
            printf("%sres_send failed\n", dbprefix);
        h_errno = TRY_AGAIN;
        return(-1);
    }

    errno = 0;    /* reset after we got an answer */

    if (n < HFIXEDSZ)
    {
        pr_error("answer length %s too short after %s query for %s",
            itoa(n), pr_type(type), name);
        h_errno = NO_RECOVERY;
        return(-1);
    }

/*
 * Analyze the status of the answer from the nameserver.
 */
    if ((verbose > print_level) || debug)
        print_status(answerbuf, n);

    bp = (HEADER *)answerbuf;
    ancount = ntohs(bp->ancount);

    if (bp->rcode != NOERROR || ancount == 0)
    {
        switch (bp->rcode)
        {
            case NXDOMAIN:
            /* distinguish between authoritative or not */
            h_errno = bp->aa ? HOST_NOT_FOUND : NO_HOST;
            break;

            case NOERROR:
            /* distinguish between authoritative or not */
            h_errno = bp->aa ? NO_DATA : NO_RREC;
            break;

            case SERVFAIL:
            h_errno = SERVER_FAILURE; /* instead of TRY_AGAIN */
            break;

            case REFUSED:
            h_errno = QUERY_REFUSED; /* instead of NO_RECOVERY */
            break;

            default:
            h_errno = NO_RECOVERY; /* FORMERR NOTIMP NOCHANGE */
            break;
        }
        return(-1);
    }

    /* valid answer received, avoid buffer overrun */
    h_errno = 0;
    return(querysize(n));
}

/*
** PRINT_INFO -- Check resource records in answer and print relevant data
** ----------------------------------------------------------------------
**
**    Returns:
**        TRUE if answer buffer was processed successfully.
**        FALSE otherwise.
**
**    Side effects:
**        Will recurse on MAILB records if appropriate.
**        See also side effects of the print_rrec() routine.
*/

bool
print_info(answerbuf, answerlen, name, type, class, regular)
input querybuf *answerbuf;        /* location of answer buffer */
input int answerlen;            /* length of answer buffer */
input char *name;            /* full name we are querying about */
input int type;                /* record type we are querying about */
input int class;            /* record class we are querying about */
input bool regular;            /* set if this is a regular lookup */
{
    HEADER *bp;
    int qdcount, ancount, nscount, arcount;
    u_char *msg, *eom;
    register u_char *cp;

    bp = (HEADER *)answerbuf;
    qdcount = ntohs(bp->qdcount);
    ancount = ntohs(bp->ancount);
    nscount = ntohs(bp->nscount);
    arcount = ntohs(bp->arcount);

    msg = (u_char *)answerbuf;
    eom = (u_char *)answerbuf + answerlen;
    cp  = (u_char *)answerbuf + HFIXEDSZ;

/*
 * Skip the query section in the response (present only in normal queries).
 */
    if (qdcount)
    {
        while (qdcount > 0 && cp < eom)    /* process all records */
        {
            cp = skip_qrec(name, type, class, cp, msg, eom);
            if (cp == NULL)
                return(FALSE);
            qdcount--;
        }

        if (qdcount)
        {
            pr_error("invalid qdcount after %s query for %s",
                pr_type(type), name);
            h_errno = NO_RECOVERY;
            return(FALSE);
        }
    }

/*
 * Process the actual answer section in the response.
 * During zone transfers, this is the only section available.
 */
    if (ancount)
    {
        if ((type != T_AXFR) && verbose && !bp->aa)
            printf("The following answer is not authoritative:\n");

        while (ancount > 0 && cp < eom)
        {
            /* reset for each record during zone listings */
            soaname = NULL, subname = NULL, adrname = NULL, address = 0;

            print_level++;
            cp = print_rrec(name, type, class, cp, msg, eom, regular);
            print_level--;
            if (cp == NULL)
                return(FALSE);
            ancount--;

            /* update zone information during zone listings */
            if (type == T_AXFR)
                update_zone(name);

            /* we trace down CNAME chains ourselves */
            if (regular && !verbose && cname)
                return(TRUE);

            /* recursively expand MR/MG records into MB records */
            if (regular && mailmode && mname)
                (void) get_recursive(&mname);
        }

        if (ancount)
        {
            pr_error("invalid ancount after %s query for %s",
                pr_type(type), name);
            h_errno = NO_RECOVERY;
            return(FALSE);
        }
    }

/*
 * The nameserver and additional info section are normally not processed.
 * Both sections shouldn't exist in zone transfers.
 */
    if (!verbose || exclusive)
        return(TRUE);

    if (nscount)
    {
        printf("Authoritative nameservers:\n");

        while (nscount > 0 && cp < eom)
        {
            print_level++;
            cp = print_rrec(name, type, class, cp, msg, eom, FALSE);
            print_level--;
            if (cp == NULL)
                return(FALSE);
            nscount--;
        }

        if (nscount)
        {
            pr_error("invalid nscount after %s query for %s",
                pr_type(type), name);
            h_errno = NO_RECOVERY;
            return(FALSE);
        }
    }

    if (arcount)
    {
        printf("Additional information:\n");

        while (arcount > 0 && cp < eom)
        {
            print_level++;
            cp = print_rrec(name, type, class, cp, msg, eom, FALSE);
            print_level--;
            if (cp == NULL)
                return(FALSE);
            arcount--;
        }

        if (arcount)
        {
            pr_error("invalid arcount after %s query for %s",
                pr_type(type), name);
            h_errno = NO_RECOVERY;
            return(FALSE);
        }
    }

    /* all sections were processed successfully */
    return(TRUE);
}

/*
** PRINT_DATA -- Output resource record data if this record is wanted
** ------------------------------------------------------------------
**
**    Returns:
**        None.
**
**    Inputs:
**        The global variable ``doprint'' is set by print_rrec()
**        if we need to print the data.
*/

static bool doprint;        /* indicates whether or not to print */

void /*VARARGS1*/
print_data(fmt, a, b, c, d)
input char *fmt;            /* format of message */
input char *a, *b, *c, *d;        /* optional arguments */
{
    /* if (doprint) */
    {
        if (!suppress)
            printf(fmt, a, b, c, d);

        if (logfile != NULL)
            (void) fprintf(logfile, fmt, a, b, c, d);
    }
}

#define doprintf(x)\
{\
    if (doprint)\
    {\
        print_data x ;\
    }\
}

/*
** PRINT_RREC -- Decode single resource record and output relevant data
** --------------------------------------------------------------------
**
**    Returns:
**        Pointer to position in answer buffer after current record.
**        NULL if there was a format error in the current record.
**
**    Outputs:
**        The global variable ``doprint'' is set appropriately
**        for use by print_data().
**
**    Side effects:
**        Updates resource record statistics in record_stats[].
**        Sets ``soaname'' if this is an SOA record.
**        Sets ``subname'' if this is an NS record.
**        Sets ``adrname'' if this is an A record.
**        Sets ``address'' if this is an A record.
**        Sets ``cname'' if this is a valid CNAME record.
**        Sets ``mname'' if this is a valid MAILB record.
**        These variables must have been cleared before calling
**        print_info() and may be checked afterwards.
*/

/* print domain names after certain conversions */
#define pr_name(x)    pr_domain(x, listing)

/* check the LHS record name of these records for invalid characters */
#define test_valid(t)    (((t == T_A) && !reverse) || t == T_MX || t == T_AAAA)

/* check the RHS domain name of these records for canonical host names */
#define test_canon(t)    (t == T_NS || t == T_MX)

u_char *
print_rrec(name, qtype, qclass, cp, msg, eom, regular)
input char *name;            /* full name we are querying about */
input int qtype;            /* record type we are querying about */
input int qclass;            /* record class we are querying about */
register u_char *cp;            /* current position in answer buf */
input u_char *msg, *eom;        /* begin and end of answer buf */
input bool regular;            /* set if this is a regular lookup */
{
    char rname[MAXDNAME+1];        /* record name in LHS */
    char dname[MAXDNAME+1];        /* domain name in RHS */
    int type, class, ttl, dlen;    /* fixed values in every record */
    u_char *eor;            /* predicted position of next record */
    bool classmatch;        /* set if we want to see this class */
    bool listing;            /* set if this is a zone listing */
    char *host = listhost;        /* contacted host for zone listings */
    register int n, c;
    struct in_addr inaddr;
    struct protoent *protocol;
    struct servent *service;

/*
 * Pickup the standard values present in each resource record.
 */
    n = expand_name(name, T_NONE, cp, msg, eom, rname);
    if (n < 0)
        return(NULL);
    cp += n;

    n = 3*INT16SZ + INT32SZ;
    if (check_size(rname, T_NONE, cp, msg, eom, n) < 0)
        return(NULL);

    type = _getshort(cp);
    cp += INT16SZ;

    class = _getshort(cp);
    cp += INT16SZ;

    ttl = _getlong(cp);
    cp += INT32SZ;

    dlen = _getshort(cp);
    cp += INT16SZ;

    eor = cp + dlen;

/*
 * Decide whether or not to print this resource record.
 */
    listing = (qtype == T_AXFR || qtype == T_IXFR) ? TRUE : FALSE;

    if (listing)
    {
        classmatch = want_class(class, queryclass);
        doprint = classmatch && want_type(type, querytype);
    }
    else
    {
        classmatch = want_class(class, C_ANY);
        doprint = classmatch && want_type(type, T_ANY);
    }

    if (doprint && exclusive && !indomain(rname, name, TRUE))
        doprint = FALSE;

    if (doprint && exclusive && fakename(rname))
        doprint = FALSE;

    if (doprint && wildcards && !in_string(rname, '*'))
        doprint = FALSE;
#ifdef justfun
    if (namelen && (strlength(rname) < namelen))
        doprint = FALSE;
#endif

/*
 * Print name and common values, if appropriate.
 */
    doprintf(("%-20s", pr_name(rname)))

    if (verbose || ttlprint)
        doprintf(("\t%s", itoa(ttl)))

    if (verbose || classprint || (class != qclass))
        doprintf(("\t%s", pr_class(class)))

    doprintf(("\t%s", pr_type(type)))

/*
 * Update resource record statistics for zone listing.
 */
    if (listing && classmatch)
    {
        if (type >= T_FIRST && type <= T_LAST)
            record_stats[type]++;
    }

/*
 * Save the domain name of an SOA or NS or A record for zone listing.
 */
    if (listing && classmatch)
    {
        if (type == T_A)
            adrname = strcpy(adrnamebuf, rname);

        else if (type == T_NS)
            subname = strcpy(subnamebuf, rname);

        else if (type == T_SOA)
            soaname = strcpy(soanamebuf, rname);
    }

/*
 * Print type specific data, if appropriate.
 */
    switch (type)
    {
        case T_A:
        if (class == C_IN || class == C_HS)
        {
            if (dlen == INADDRSZ)
            {
                bcopy((char *)cp, (char *)&inaddr, INADDRSZ);
                address = inaddr.s_addr;
                doprintf(("\t%s", inet_ntoa(inaddr)))
                cp += INADDRSZ;
                break;
            }
#ifdef obsolete
            if (dlen == INADDRSZ + 1 + INT16SZ)
            {
                bcopy((char *)cp, (char *)&inaddr, INADDRSZ);
                address = inaddr.s_addr;
                doprintf(("\t%s", inet_ntoa(inaddr)))
                cp += INADDRSZ;

                n = *cp++;
                doprintf((" ; proto = %s", itoa(n)))

                n = _getshort(cp);
                doprintf((", port = %s", itoa(n)))
                cp += INT16SZ;
                break;
            }
#endif
            address = 0;
            break;
        }
        address = 0;
        cp += dlen;
        break;

        case T_MX:
        if (check_size(rname, type, cp, msg, eor, INT16SZ) < 0)
            break;
        n = _getshort(cp);
        doprintf(("\t%s", itoa(n)))
        cp += INT16SZ;

        n = expand_name(rname, type, cp, msg, eom, dname);
        if (n < 0)
            break;
        doprintf((" %s", pr_name(dname)))
        cp += n;
        break;

        case T_NS:
        case T_PTR:
        case T_CNAME:
        n = expand_name(rname, type, cp, msg, eom, dname);
        if (n < 0)
            break;
        doprintf(("\t%s", pr_name(dname)))
        cp += n;
        break;

        case T_HINFO:
        if (check_size(rname, type, cp, msg, eor, 1) < 0)
            break;
        n = *cp++;
        doprintf(("\t\"%s\"", stoa(cp, n, TRUE)))
        cp += n;

        if (check_size(rname, type, cp, msg, eor, 1) < 0)
            break;
        n = *cp++;
        doprintf(("\t\"%s\"", stoa(cp, n, TRUE)))
        cp += n;
        break;

        case T_SOA:
        n = expand_name(rname, type, cp, msg, eom, dname);
        if (n < 0)
            break;
        doprintf(("\t%s", pr_name(dname)))
        cp += n;

        n = expand_name(rname, type, cp, msg, eom, dname);
        if (n < 0)
            break;
        doprintf((" %s", pr_name(dname)))
        cp += n;

        n = 5*INT32SZ;
        if (check_size(rname, type, cp, msg, eor, n) < 0)
            break;
        doprintf((" ("))

        n = _getlong(cp);
        doprintf(("\n\t\t\t%s", utoa(n)))
        doprintf(("\t;serial (version)"))
        cp += INT32SZ;

        n = _getlong(cp);
        doprintf(("\n\t\t\t%s", itoa(n)))
        doprintf(("\t;refresh period (%s)", pr_time(n, FALSE)))
        cp += INT32SZ;

        n = _getlong(cp);
        doprintf(("\n\t\t\t%s", itoa(n)))
        doprintf(("\t;retry interval (%s)", pr_time(n, FALSE)))
        cp += INT32SZ;

        n = _getlong(cp);
        doprintf(("\n\t\t\t%s", itoa(n)))
        doprintf(("\t;expire time (%s)", pr_time(n, FALSE)))
        cp += INT32SZ;

        n = _getlong(cp);
        doprintf(("\n\t\t\t%s", itoa(n)))
        doprintf(("\t;default ttl (%s)", pr_time(n, FALSE)))
        cp += INT32SZ;

        doprintf(("\n\t\t\t)"))
        break;

        case T_WKS:
        if (check_size(rname, type, cp, msg, eor, INADDRSZ) < 0)
            break;
        bcopy((char *)cp, (char *)&inaddr, INADDRSZ);
        doprintf(("\t%s", inet_ntoa(inaddr)))
        cp += INADDRSZ;

        if (check_size(rname, type, cp, msg, eor, 1) < 0)
            break;
        n = *cp++;

        protocol = getprotobynumber(n);
        if (protocol != NULL)
            doprintf((" %s", protocol->p_name))
        else
            doprintf((" %s", itoa(n)))

        doprintf((" ("))
        n = 0;
        while (cp < eor)
        {
            c = *cp++;
            do
            {
             if (c & 0200)
            {
                int port;

                port = htons(n);
                if (protocol != NULL)
                    service = getservbyport(port, protocol->p_name);
                else
                    service = NULL;

                if (service != NULL)
                    doprintf((" %s", service->s_name))
                else
                    doprintf((" %s", itoa(n)))
            }
             c <<= 1;
            } while (++n & 07);
        }
        doprintf((" )"))
        break;

#ifdef obsolete
        case T_TXT:
        /* if (dlen > 0) */
        {
            doprintf(("\t\"%s\"", stoa(cp, dlen, TRUE)))
            cp += dlen;
        }
        break;
#endif

        case T_TXT:
        if (check_size(rname, type, cp, msg, eor, 1) < 0)
            break;
        n = *cp++;
        doprintf(("\t\"%s\"", stoa(cp, n, TRUE)))
        cp += n;

        while (cp < eor)
        {
            if (check_size(rname, type, cp, msg, eor, 1) < 0)
                break;
            n = *cp++;
            doprintf((" \"%s\"", stoa(cp, n, TRUE)))
            cp += n;
        }
        break;

        case T_MINFO:
        n = expand_name(rname, type, cp, msg, eom, dname);
        if (n < 0)
            break;
        doprintf(("\t%s", pr_name(dname)))
        cp += n;

        n = expand_name(rname, type, cp, msg, eom, dname);
        if (n < 0)
            break;
        doprintf((" %s", pr_name(dname)))
        cp += n;
        break;

        case T_MB:
        case T_MG:
        case T_MR:
        case T_MD:
        case T_MF:
        n = expand_name(rname, type, cp, msg, eom, dname);
        if (n < 0)
            break;
        doprintf(("\t%s", pr_name(dname)))
        cp += n;
        break;

        case T_UID:
        case T_GID:
        if (dlen == INT32SZ)
        {
            n = _getlong(cp);
            doprintf(("\t%s", itoa(n)))
            cp += INT32SZ;
        }
        break;

        case T_UINFO:
        doprintf(("\t\"%s\"", stoa(cp, dlen, TRUE)))
        cp += dlen;
        break;

        case T_RP:
        n = expand_name(rname, type, cp, msg, eom, dname);
        if (n < 0)
            break;
        doprintf(("\t%s", pr_name(dname)))
        cp += n;

        n = expand_name(rname, type, cp, msg, eom, dname);
        if (n < 0)
            break;
        doprintf((" %s", pr_name(dname)))
        cp += n;
        break;

        case T_RT:
        if (check_size(rname, type, cp, msg, eor, INT16SZ) < 0)
            break;
        n = _getshort(cp);
        doprintf(("\t%s", itoa(n)))
        cp += INT16SZ;

        n = expand_name(rname, type, cp, msg, eom, dname);
        if (n < 0)
            break;
        doprintf((" %s", pr_name(dname)))
        cp += n;
        break;

        case T_AFSDB:
        if (check_size(rname, type, cp, msg, eor, INT16SZ) < 0)
            break;
        n = _getshort(cp);
        doprintf(("\t%s", itoa(n)))
        cp += INT16SZ;

        n = expand_name(rname, type, cp, msg, eom, dname);
        if (n < 0)
            break;
        doprintf((" %s", pr_name(dname)))
        cp += n;
        break;

        case T_X25:
        if (check_size(rname, type, cp, msg, eor, 1) < 0)
            break;
        n = *cp++;
        doprintf(("\t%s", stoa(cp, n, FALSE)))
        cp += n;
        break;

        case T_ISDN:
        if (check_size(rname, type, cp, msg, eor, 1) < 0)
            break;
        n = *cp++;
        doprintf(("\t%s", stoa(cp, n, FALSE)))
        cp += n;

        if (cp < eor)
        {
            if (check_size(rname, type, cp, msg, eor, 1) < 0)
                break;
            n = *cp++;
            doprintf((" %s", stoa(cp, n, FALSE)))
            cp += n;
        }
        break;

        case T_NSAP:
        doprintf(("\t0x%s", nsap_ntoa(cp, dlen)))
        cp += dlen;
        break;

        case T_NSAPPTR:
        n = expand_name(rname, type, cp, msg, eom, dname);
        if (n < 0)
            break;
        doprintf(("\t%s", pr_name(dname)))
        cp += n;
        break;

        case T_PX:
        if (check_size(rname, type, cp, msg, eor, INT16SZ) < 0)
            break;
        n = _getshort(cp);
        doprintf(("\t%s", itoa(n)))
        cp += INT16SZ;

        n = expand_name(rname, type, cp, msg, eom, dname);
        if (n < 0)
            break;
        doprintf((" %s", pr_name(dname)))
        cp += n;

        n = expand_name(rname, type, cp, msg, eom, dname);
        if (n < 0)
            break;
        doprintf((" %s", pr_name(dname)))
        cp += n;
        break;

        case T_GPOS:
        if (check_size(rname, type, cp, msg, eor, 1) < 0)
            break;
        n = *cp++;
        doprintf(("\t%s", stoa(cp, n, FALSE)))
        cp += n;

        if (check_size(rname, type, cp, msg, eor, 1) < 0)
            break;
        n = *cp++;
        doprintf(("\t%s", stoa(cp, n, FALSE)))
        cp += n;

        if (check_size(rname, type, cp, msg, eor, 1) < 0)
            break;
        n = *cp++;
        doprintf(("\t%s", stoa(cp, n, FALSE)))
        cp += n;
        break;

        case T_LOC:
        if ((n = *cp) != T_LOC_VERSION)
        {
            pr_error("invalid version %s in %s record for %s",
                itoa(n), pr_type(type), rname);
            cp += dlen;
            break;
        }

        n = INT32SZ + 3*INT32SZ;
        if (check_size(rname, type, cp, msg, eor, n) < 0)
            break;
        c = _getlong(cp);
        cp += INT32SZ;

        n = _getlong(cp);
        doprintf(("\t%s ", pr_spherical(n, "N", "S")))
        cp += INT32SZ;

        n = _getlong(cp);
        doprintf((" %s ", pr_spherical(n, "E", "W")))
        cp += INT32SZ;

        n = _getlong(cp);
        doprintf((" %sm ", pr_vertical(n, "", "-")))
        cp += INT32SZ;

        doprintf((" %sm", pr_precision((c >> 16) & 0xff)))
        doprintf((" %sm", pr_precision((c >>  8) & 0xff)))
        doprintf((" %sm", pr_precision((c >>  0) & 0xff)))
        break;

        case T_UNSPEC:
        case T_NULL:
        cp += dlen;
        break;

        case T_AAAA:
        if (dlen == IPNGSIZE)
        {
            doprintf(("\t%s", ipng_ntoa(cp)))
            cp += IPNGSIZE;
        }
        break;

        case T_SIG:
        if (check_size(rname, type, cp, msg, eor, INT16SZ) < 0)
            break;
        n = _getshort(cp);
        doprintf(("\t%s", pr_type(n)))
        cp += INT16SZ;

        if (check_size(rname, type, cp, msg, eor, 1) < 0)
            break;
        n = *cp++;
        doprintf((" %s", itoa(n)))

        n = 1 + 3*INT32SZ + INT16SZ;
        if (check_size(rname, type, cp, msg, eor, n) < 0)
            break;
        doprintf((" ("))

        n = *cp++;
        doprintf(("\n\t\t\t; %s", itoa(n)))
        doprintf(("\t\t;labels"))

        n = _getlong(cp);
        doprintf(("\n\t\t\t%s", itoa(n)))
        doprintf(("\t\t;original ttl"))
        cp += INT32SZ;

        n = _getlong(cp);
        doprintf(("\n\t\t\t%s", pr_date(n)))
        doprintf(("\t;signature expiration"))
        cp += INT32SZ;

        n = _getlong(cp);
        doprintf(("\n\t\t\t%s", pr_date(n)))
        doprintf(("\t;signature signed time"))
        cp += INT32SZ;

        n = _getshort(cp);
        doprintf(("\n\t\t\t%s", itoa(n)))
        doprintf(("\t\t;key footprint"))
        cp += INT16SZ;

        n = expand_name(rname, type, cp, msg, eom, dname);
        if (n < 0)
            break;
        doprintf(("\n\t\t\t%s", pr_name(dname)))
        cp += n;

        if (cp < eor)
        {
            register char *buf;
            register int size;

            n = eor - cp;
            buf = base_ntoa(cp, n);
            size = strlength(buf);
            cp += n;

            while ((n = (size > 64) ? 64 : size) > 0)
            {
                doprintf(("\n\t%s", stoa((u_char *)buf, n, FALSE)))
                buf += n; size -= n;
            }
        }

        doprintf(("\n\t\t\t)"))
        break;

        case T_KEY:
        if (check_size(rname, type, cp, msg, eor, INT16SZ) < 0)
            break;
        n = _getshort(cp);
        doprintf(("\t0x%s", xtoa(n)))
        cp += INT16SZ;

        if (check_size(rname, type, cp, msg, eor, 1) < 0)
            break;
        n = *cp++;
        doprintf((" %s", itoa(n)))

        if (check_size(rname, type, cp, msg, eor, 1) < 0)
            break;
        n = *cp++;
        doprintf((" %s", itoa(n)))

        if (cp < eor)
        {
            register char *buf;
            register int size;

            n = eor - cp;
            buf = base_ntoa(cp, n);
            size = strlength(buf);
            cp += n;

            doprintf((" ("))
            while ((n = (size > 64) ? 64 : size) > 0)
            {
                doprintf(("\n\t%s", stoa((u_char *)buf, n, FALSE)))
                buf += n; size -= n;
            }
            doprintf(("\n\t\t\t)"))
        }
        break;

        case T_NXT:
        n = expand_name(rname, type, cp, msg, eom, dname);
        if (n < 0)
            break;
        doprintf(("\t%s", pr_name(dname)))
        cp += n;

        n = 0;
        while (cp < eor)
        {
            c = *cp++;
            do
            {
             if (c & 0200)
            {
                doprintf((" %s", pr_type(n)))
            }
             c <<= 1;
            } while (++n & 07);
        }
        break;

        case T_SRV:
        if (check_size(rname, type, cp, msg, eor, INT16SZ) < 0)
            break;
        n = _getshort(cp);
        doprintf(("\t%s", itoa(n)))
        cp += INT16SZ;

        if (check_size(rname, type, cp, msg, eor, INT16SZ) < 0)
            break;
        n = _getshort(cp);
        doprintf((" %s", itoa(n)))
        cp += INT16SZ;

        if (check_size(rname, type, cp, msg, eor, INT16SZ) < 0)
            break;
        n = _getshort(cp);
        doprintf((" %s", itoa(n)))
        cp += INT16SZ;

        n = expand_name(rname, type, cp, msg, eom, dname);
        if (n < 0)
            break;
        doprintf((" %s", pr_name(dname)))
        cp += n;
        break;

        case T_EID:
        case T_NIMLOC:
        case T_ATMA:
        doprintf(("\t\"not yet implemented\""))
        cp += dlen;
        break;

        case T_NAPTR:
        if (check_size(rname, type, cp, msg, eor, INT16SZ) < 0)
            break;
        n = _getshort(cp);
        doprintf(("\t%s", itoa(n)))
        cp += INT16SZ;

        if (check_size(rname, type, cp, msg, eor, INT16SZ) < 0)
            break;
        n = _getshort(cp);
        doprintf((" %s", itoa(n)))
        cp += INT16SZ;

        if (check_size(rname, type, cp, msg, eor, 1) < 0)
            break;
        n = *cp++;
        doprintf((" \"%s\"", stoa(cp, n, TRUE)))
        cp += n;

        if (check_size(rname, type, cp, msg, eor, 1) < 0)
            break;
        n = *cp++;
        doprintf((" \"%s\"", stoa(cp, n, TRUE)))
        cp += n;

        if (check_size(rname, type, cp, msg, eor, 1) < 0)
            break;
        n = *cp++;
        doprintf((" \"%s\"", stoa(cp, n, TRUE)))
        cp += n;

        n = expand_name(rname, type, cp, msg, eom, dname);
        if (n < 0)
            break;
        doprintf((" %s", pr_name(dname)))
        cp += n;
        break;
#ifdef notyet
        case T_TSIG:
        if (check_size(rname, type, cp, msg, eor, 1) < 0)
            break;
        n = *cp++;
        doprintf(("\t\"%s\"", stoa(cp, n, TRUE)))
        cp += n;

        while (cp < eor)
        {
            if (check_size(rname, type, cp, msg, eor, 1) < 0)
                break;
            n = *cp++;
            doprintf((" \"%s\"", stoa(cp, n, TRUE)))
            cp += n;
        }
        break;
#endif
        default:
        doprintf(("\t\"???\""))
        cp += dlen;
        break;
    }

/*
 * End of specific data type processing.
 * Terminate resource record printout.
 */
    doprintf(("\n"))

/*
 * Check whether we have reached the exact end of this resource record.
 * If not, we cannot be sure that the record has been decoded correctly,
 * and therefore the subsequent tests will be skipped.
 */
    if (cp != eor)
    {
        pr_error("size error in %s record for %s, off by %s",
            pr_type(type), rname, itoa(cp - eor));

        /* we believe value of dlen; should perhaps return(NULL) */
        return(eor);
    }

/*
 * Save the CNAME alias for cname chain tracing.
 * Save the MR or MG alias for MB chain tracing.
 * These features can be enabled only in normal mode.
 */
    if (regular && classmatch)
    {
        if (type == T_CNAME)
            cname = strcpy(cnamebuf, dname);

        else if (type == T_MR || type == T_MG)
            mname = strcpy(mnamebuf, dname);
    }

/*
 * Suppress the subsequent checks in quiet mode.
 * This can safely be done as there are no side effects.
 * It may speedup things, and nothing would be printed anyway.
 */
    if (quiet)
        return(cp);

/*
 * In zone listings, resource records with the same name/type/class
 * must have the same ttl value. Maintain and check list of record info.
 * This is done on a per-zone basis.
 */
    if (listing && !check_ttl(rname, type, class, ttl))
    {
        pr_warning("%s %s records have different ttl within %s from %s",
            rname, pr_type(type), name, host);
    }

/*
 * Check validity of 'host' related domain names in certain resource records.
 * These include LHS record names and RHS domain names of selected records.
 * Currently underscores are not reported during deep recursive listings.
 */
    if (test_valid(type) && !valid_name(rname, TRUE, FALSE, recurskip))
    {
        pr_warning("%s %s record has illegal name",
            rname, pr_type(type));
    }

    if (test_canon(type) && !valid_name(dname, FALSE, FALSE, recurskip))
    {
        pr_warning("%s %s host %s has illegal name",
            rname, pr_type(type), dname);
    }

/*
 * The RHS of various resource records should refer to a canonical host name,
 * i.e. it should exist and have an A record and not be a CNAME.
 * Currently this test is suppressed during deep recursive zone listings.
 */
    if (!recurskip && test_canon(type) && ((n = check_canon(dname)) != 0))
    {
        /* only report definitive target host failures */
        if (n == HOST_NOT_FOUND)
            pr_warning("%s %s host %s does not exist",
                rname, pr_type(type), dname);
        else if (n == NO_DATA)
            pr_warning("%s %s host %s has no A record",
                rname, pr_type(type), dname);
        else if (n == HOST_NOT_CANON)
            pr_warning("%s %s host %s is not canonical",
                rname, pr_type(type), dname);

        /* authoritative failure to find nameserver target host */
        if (type == T_NS && (n == NO_DATA || n == HOST_NOT_FOUND))
        {
            if (server == NULL)
                errmsg("%s has lame delegation to %s",
                    rname, dname);
        }
    }

/*
 * On request, reverse map the address of an A record, and verify that
 * it is registered and maps back to the name of the A record.
 * Currently this option has effect here only during zone listings.
 */
    if (addrmode && ((type == T_A) && !reverse) && !fakeaddr(address))
    {
        host = mapreverse(rname, inaddr);
        if (host == NULL)
            pr_warning("%s address %s is not registered",
                rname, inet_ntoa(inaddr));
        else if (host != rname)
            pr_warning("%s address %s maps to %s",
                rname, inet_ntoa(inaddr), host);
    }

/*
 * This record was processed successfully.
 */
    return(cp);
}

/*
** SKIP_QREC -- Skip the query record in the nameserver answer buffer
** ------------------------------------------------------------------
**
**    Returns:
**        Pointer to position in answer buffer after current record.
**        NULL if there was a format error in the current record.
*/

u_char *
skip_qrec(name, qtype, qclass, cp, msg, eom)
input char *name;            /* full name we are querying about */
input int qtype;            /* record type we are querying about */
input int qclass;            /* record class we are querying about */
register u_char *cp;            /* current position in answer buf */
input u_char *msg, *eom;        /* begin and end of answer buf */
{
    char rname[MAXDNAME+1];        /* record name in LHS */
    int type, class;        /* fixed values in query record */
    register int n;

/*
 * Pickup the standard values present in the query section.
 */
    n = expand_name(name, T_NONE, cp, msg, eom, rname);
    if (n < 0)
        return(NULL);
    cp += n;

    n = 2*INT16SZ;
    if (check_size(rname, T_NONE, cp, msg, eom, n) < 0)
        return(NULL);

    type = _getshort(cp);
    cp += INT16SZ;

    class = _getshort(cp);
    cp += INT16SZ;

#ifdef lint
    if (verbose)
        printf("%-20s\t%s\t%s\n",
            rname, pr_class(class), pr_type(type));
#endif

/*
 * The values in the answer should match those in the query.
 * If there is a mismatch, we just signal an error, but don't abort.
 * For regular queries there is exactly one record in the query section.
 */
    if (!sameword(rname, name))
        pr_error("invalid answer name %s after %s query for %s",
            rname, pr_type(qtype), name);

    if (type != qtype)
        pr_error("invalid answer type %s after %s query for %s",
            pr_type(type), pr_type(qtype), name);

    if (class != qclass)
        pr_error("invalid answer class %s after %s query for %s",
            pr_class(class), pr_type(qtype), name);

    return(cp);
}

/*
** GET_RECURSIVE -- Wrapper for get_hostinfo() during recursion
** ------------------------------------------------------------
**
**    Returns:
**        TRUE if requested info was obtained successfully.
**        FALSE otherwise.
*/

bool
get_recursive(name)
input char **name;            /* name to query about */
{
    static int level = 0;        /* recursion level */
    char newnamebuf[MAXDNAME+1];
    char *newname;            /* new name to look up */
    bool result;            /* result status of action taken */
    int save_errno;
    int save_herrno;

    if (level > MAXCHAIN)
    {
        errmsg("Recursion too deep");
        return(FALSE);
    }

    /* save local copy, and reset indicator */
    newname = strcpy(newnamebuf, *name);
    *name = NULL;

    save_errno = errno;
    save_herrno = h_errno;

    level++;
    result = get_hostinfo(newname, TRUE);
    level--;

    errno = save_errno;
    h_errno = save_herrno;

    return(result);
}


/*
 * Nameserver information.
 * Stores names and addresses of all servers that are to be queried
 * for a zone transfer of the desired zone. Normally these are the
 * authoritative primary and/or secondary nameservers for the zone.
 */

char nsname[MAXNSNAME][MAXDNAME+1];        /* nameserver host name */
struct in_addr ipaddr[MAXNSNAME][MAXIPADDR];    /* nameserver addresses */
int naddrs[MAXNSNAME];                /* count of addresses */
int nservers = 0;                /* count of nameservers */

#ifdef notyet
typedef struct srvr_data {
    char sd_nsname[MAXDNAME+1];        /* nameserver host name */
    struct in_addr sd_ipaddr[MAXIPADDR];    /* nameserver addresses */
    int sd_naddrs;                /* count of addresses */
} srvr_data_t;

srvr_data_t nsinfo[MAXNSNAME];    /* nameserver info */
#endif

bool authserver;        /* server is supposed to be authoritative */
bool lameserver;        /* server could not provide SOA service */

/*
 * Host information.
 * Stores names and (single) addresses encountered during the zone listing
 * of all A records that belong to the zone. Non-authoritative glue records
 * that do not belong to the zone are not stored. Glue records that belong
 * to a delegated zone will be filtered out later during the host count scan.
 * The host names are allocated dynamically.
 * The list itself is also allocated dynamically, to avoid static limits,
 * and to keep the initial bss of the executable to a reasonable size.
 * Allocation is done in chunks, to reduce considerable malloc overhead.
 * Note that the list will not shrink during recursive processing.
 */

#ifdef obsolete
char *hostname[MAXHOSTS];    /* host name of host in zone */
ipaddr_t hostaddr[MAXHOSTS];    /* first host address */
bool multaddr[MAXHOSTS];    /* set if this is a multiple address host */
#endif

typedef struct host_data {
    char *hd_hostname;    /* host name of host in zone */
    ipaddr_t hd_hostaddr;    /* first host address */
    bool hd_multaddr;    /* set if this is a multiple address host */
} host_data_t;

host_data_t *hostlist = NULL;    /* info on hosts in zone */
int hostcount = 0;        /* count of hosts in zone */

int maxhosts = 0;        /* number of allocated hostlist entries */

#define MAXHOSTINCR    4096    /* chunk size to increment hostlist */

#define hostname(i)    hostlist[i].hd_hostname
#define hostaddr(i)    hostlist[i].hd_hostaddr
#define multaddr(i)    hostlist[i].hd_multaddr

/*
 * Delegated zone information.
 * Stores the names of the delegated zones encountered during the zone
 * listing. The names and the list itself are allocated dynamically.
 */

char **zonename = NULL;        /* names of delegated zones within zone */
int zonecount = 0;        /* count of delegated zones within zone */

/*
 * Address information.
 * Stores the (single) addresses of hosts found in all zones traversed.
 * Used to search for duplicate hosts (same address but different name).
 * The list of addresses is allocated dynamically, and remains allocated.
 * This has now been implemented as a hashed list, using the low-order
 * address bits as the hash key.
 */

#ifdef obsolete
ipaddr_t *addrlist = NULL;    /* global list of addresses */
int addrcount = 0;        /* count of global addresses */
#endif

/*
 * SOA record information.
 */

soa_data_t soa;            /* buffer to store soa data */

int soacount = 0;        /* count of SOA records during listing */

/*
 * Nameserver preference.
 * As per BIND 4.9.* resource records may be returned after round-robin
 * reshuffling each time they are retrieved. For NS records, this may
 * lead to an unfavorable order for doing zone transfers.
 * We apply some heuristic to sort the NS records according to their
 * preference with respect to a given list of preferred server domains.
 */

int nsrank[MAXNSNAME];        /* nameserver ranking after sorting */
int nspref[MAXNSNAME];        /* nameserver preference value */

/*
** LIST_ZONE -- Basic routine to do complete zone listing and checking
** -------------------------------------------------------------------
**
**    Returns:
**        TRUE if the requested info was processed successfully.
**        FALSE otherwise.
*/

int total_calls = 0;        /* number of calls for zone processing */
int total_check = 0;        /* number of zones successfully processed */
int total_tries = 0;        /* number of zone transfer attempts */
int total_zones = 0;        /* number of successful zone transfers */
int total_hosts = 0;        /* number of hosts in all traversed zones */
int total_dupls = 0;        /* number of duplicates in all zones */

#ifdef justfun
char longname[MAXDNAME+1];    /* longest host name found */
int longsize = 0;        /* size of longest host name */
#endif

bool
list_zone(name)
input char *name;            /* name of zone to process */
{
    register int n;
    register int i;
    int nzones;            /* count of delegated zones */
    int nhosts;            /* count of real host names */
    int ndupls;            /* count of duplicate hosts */
    int nextrs;            /* count of extrazone hosts */
    int ngates;            /* count of gateway hosts */

    total_calls += 1;        /* update zone processing calls */

/*
 * Normalize to not have trailing dot, unless it is the root zone.
 */
    n = strlength(name);
    if (n > 1 && name[n-1] == '.')
        name[n-1] = '\0';

/*
 * Indicate whether we are processing an in-addr.arpa reverse zone.
 * In this case we will suppress accumulating host count statistics.
 */
    reverse = indomain(name, ARPA_ROOT, FALSE);

/*
 * Suppress various checks if working beyond the recursion skip level.
 * This affects processing in print_rrec(). It may need refinement.
 */
    recurskip = ((recursion_level > skip_level) && !addrmode) ? TRUE : FALSE;

/*
 * Find the nameservers for the given zone.
 */
    (void) find_servers(name);

    if (nservers < 1)
    {
        errmsg("No nameservers for %s found", name);
        return(FALSE);
    }

/*
 * Make sure we have an address for at least one nameserver.
 */
    for (n = 0; n < nservers; n++)
        if (naddrs[n] > 0)
            break;

    if (n >= nservers)
    {
        errmsg("No addresses of nameservers for %s found", name);
        return(FALSE);
    }

/*
 * Without an explicit server on the command line, the servers we
 * have looked up are supposed to be authoritative for the zone.
 */
    authserver = (server && !primary) ? FALSE : TRUE;

/*
 * Check SOA records at each of the nameservers if so requested.
 */
    if (checkmode)
    {
        do_check(name);

        total_check += 1;    /* update zones processed */

        /* all done if maximum recursion level reached */
        if (!recursive || (recursion_level >= recursive))
            return((errorcount == 0) ? TRUE : FALSE);
    }

/*
 * The zone transfer for certain zones can be skipped.
 * Currently this must be indicated on the command line.
 */
    if (skip_transfer(name))
    {
        if (verbose || statistics || checkmode || hostmode)
            printf("Skipping zone transfer for %s\n", name);
        return(FALSE);
    }

/*
 * Ask zone transfer to the nameservers, until one responds.
 */
    total_tries += 1;        /* update zone transfer attempts */

    if (!do_transfer(name))
        return(FALSE);

    total_zones += 1;        /* update successful zone transfers */

/*
 * Print resource record statistics if so requested.
 */
    if (statistics)
        print_statistics(name, querytype, queryclass);

/*
 * Accumulate host count statistics for this zone.
 * Do this only in modes in which such output would be printed.
 */
    nzones = zonecount;

    nhosts = 0, ndupls = 0, nextrs = 0, ngates = 0;

    i = (verbose || statistics || hostmode) ? 0 : hostcount;

    for (n = i; n < hostcount; n++)
    {
        /* skip fake hosts using a very rudimentary test */
        if (fakename(hostname(n)) || fakeaddr(hostaddr(n)))
            continue;
#ifdef justfun
        /* save longest host name encountered so far */
        if (verbose && ((i = strlength(hostname(n))) > longsize))
        {
            longsize = i;
            (void) strcpy(longname, hostname(n));
        }
#endif
        /* skip apparent glue records */
        if (gluerecord(hostname(n), name, zonename, nzones))
        {
            if (verbose > 1)
                printf("%s is glue record\n", hostname(n));
            continue;
        }

        /* otherwise count as host */
        nhosts++;

    /*
     * Mark hosts not residing directly in the zone as extrazone host.
     */
        if (!samedomain(hostname(n), name, TRUE))
        {
            nextrs++;
            if (extrmode || (verbose > 1))
                printf("%s is extrazone host\n", hostname(n));
        }

    /*
     * Mark hosts with more than one address as gateway host.
     * These are not checked for duplicate addresses.
     */
        if (multaddr(n))
        {
            ngates++;
            if (gatemode || (verbose > 1))
                printf("%s is gateway host\n", hostname(n));
        }

    /*
     * Compare single address hosts against global list of addresses.
     * Multiple address hosts are too complicated to handle this way.
     */
        else if (check_dupl(hostaddr(n)))
        {
            struct in_addr inaddr;
            inaddr.s_addr = hostaddr(n);

            ndupls++;
            if (duplmode || (verbose > 1))
                printf("%s is duplicate host with address %s\n",
                    hostname(n), inet_ntoa(inaddr));
        }
    }

/*
 * Print statistics for this zone.
 */
    if (verbose || statistics || hostmode)
    {
        printf("Found %d host%s within %s\n",
            nhosts, plural(nhosts), name);

        if ((ndupls > 0) || duplmode || (verbose > 1))
        printf("Found %d duplicate host%s within %s\n",
            ndupls, plural(ndupls), name);

        if ((nextrs > 0) || extrmode || (verbose > 1))
        printf("Found %d extrazone host%s within %s\n",
            nextrs, plural(nextrs), name);

        if ((ngates > 0) || gatemode || (verbose > 1))
        printf("Found %d gateway host%s within %s\n",
            ngates, plural(ngates), name);
    }

    total_hosts += nhosts;        /* update total number of hosts */
    total_dupls += ndupls;        /* update total number of duplicates */

    if (!checkmode)
        total_check += 1;    /* update zones processed */

    if (verbose || statistics)
        printf("Found %d delegated zone%s within %s\n",
            nzones, plural(nzones), name);

/*
 * Sort the encountered delegated zones alphabetically.
 * Note that this precludes further use of the zone_index() function.
 */
    if ((nzones > 1) && (recursive || listzones || mxdomains))
        qsort((ptr_t *)zonename, nzones, sizeof(char *), compare_name);

/*
 * The names of the hosts were allocated dynamically.
 */
    for (n = 0; n < hostcount; n++)
        xfree(hostname(n));

/*
 * Check for mailable delegated zones within this zone.
 * This is based on ordinary MX lookup, and not on the MX info
 * which may be present in the zone listing, to reduce zone transfers.
 */
    if (mxdomains)
    {
        if (recursion_level == 0)
        {
            if (verbose)
                printf("\n");

            if (!get_mxrec(name))
                ns_error(name, T_MX, queryclass, server);
        }

        for (n = 0; n < nzones; n++)
        {
            if (verbose)
                printf("\n");

            if (!get_mxrec(zonename[n]))
                ns_error(zonename[n], T_MX, queryclass, server);
        }
    }

/*
 * Do recursion on delegated zones if requested and any were found.
 * Temporarily save zonename list, and force allocation of new list.
 */
    if (recursive && (recursion_level < recursive))
    {
        for (n = 0; n < nzones; n++)
        {
            char **newzone;        /* local copy of list */

            newzone = zonename;
            zonename = NULL;    /* allocate new list */

            if (verbose || statistics || checkmode || hostmode)
                printf("\n");

            if (listzones)
            {
                for (i = 0; i <= recursion_level; i++)
                    printf("%s", (i == 0) ? "\t" : "  ");
                printf("%s\n", newzone[n]);
            }

            if (verbose)
                printf("Entering zone %s\n", newzone[n]);

            recursion_level++;
            (void) list_zone(newzone[n]);
            recursion_level--;

            zonename = newzone;    /* restore */
        }
    }
    else if (listzones)
    {
        for (n = 0; n < nzones; n++)
        {
            for (i = 0; i <= recursion_level; i++)
                printf("%s", (i == 0) ? "\t" : "  ");
            printf("%s\n", zonename[n]);
        }
    }

/*
 * The names of the delegated zones were allocated dynamically.
 * The list of delegated zone names was also allocated dynamically.
 */
    for (n = 0; n < nzones; n++)
        xfree(zonename[n]);

    if (zonename != NULL)
        xfree(zonename);

    zonename = NULL;

/*
 * Print final overall statistics.
 */
    if (recursive && (recursion_level == 0))
    {
        if (verbose || statistics || checkmode || hostmode)
            printf("\n");

        if (verbose || statistics || hostmode)
            printf("Encountered %d host%s in %d zone%s within %s\n",
                total_hosts, plural(total_hosts),
                total_zones, plural(total_zones),
                name);

        if (verbose || statistics || hostmode)
            printf("Encountered %d duplicate host%s in %d zone%s within %s\n",
                total_dupls, plural(total_dupls),
                total_zones, plural(total_zones),
                name);

        if (verbose || statistics || checkmode)
            printf("Transferred %d zone%s out of %d attempt%s\n",
                total_zones, plural(total_zones),
                total_tries, plural(total_tries));

        if (verbose || statistics || checkmode)
            printf("Processed %d zone%s out of %d request%s\n",
                total_check, plural(total_check),
                total_calls, plural(total_calls));
#ifdef justfun
        if (verbose && (longsize > 0))
            printf("Longest hostname %s\t%d\n",
                longname, longsize);
#endif
    }

    /* indicate whether any errors were encountered */
    return((errorcount == 0) ? TRUE : FALSE);
}

/*
** FIND_SERVERS -- Fetch names and addresses of authoritative servers
** ------------------------------------------------------------------
**
**    Returns:
**        TRUE if servers could be determined successfully.
**        FALSE otherwise.
**
**    Inputs:
**        The global variable ``server'', if set, contains the
**        name of the explicit server to be contacted.
**        The global variable ``primary'', if set, indicates
**        that we must use the primary nameserver for the zone.
**        If both are set simultaneously, the explicit server
**        is contacted to retrieve the desired servers.
**
**    Outputs:
**        The count of nameservers is stored in ``nservers''.
**        Names are stored in the nsname[] database.
**        Addresses are stored in the ipaddr[] database.
**        Address counts are stored in the naddrs[] database.
*/

bool
find_servers(name)
input char *name;            /* name of zone to find servers for */
{
    struct hostent *hp;
    register int n, i;

/*
 * Use the explicit server if given on the command line.
 * Its addresses are stored in the resolver state struct.
 * This server may not be authoritative for the given zone.
 */
    if (server && !primary)
    {
        (void) strcpy(nsname[0], server);

        for (i = 0; i < MAXIPADDR && i < _res.nscount; i++)
            ipaddr[0][i] = nslist(i).sin_addr;
        naddrs[0] = i;

        nservers = 1;
        return(TRUE);
    }

/*
 * Fetch primary nameserver info if so requested.
 * Get its name from the SOA record for the zone, and do a regular
 * host lookup to fetch its addresses. We are assuming here that the
 * SOA record is a proper one. This is not necessarily true.
 * Obviously this server should be authoritative.
 */
    if (primary && !server)
    {
        char *primaryname;

        primaryname = get_primary(name);
        if (primaryname == NULL)
        {
            ns_error(name, T_SOA, queryclass, server);
            nservers = 0;
            return(FALSE);
        }

        hp = geth_byname(primaryname);
        if (hp == NULL)
        {
            ns_error(primaryname, T_A, C_IN, server);
            nservers = 0;
            return(FALSE);
        }

        primaryname = strncpy(nsname[0], hp->h_name, MAXDNAME);
        primaryname[MAXDNAME] = '\0';

        for (i = 0; i < MAXIPADDR && hp->h_addr_list[i]; i++)
            ipaddr[0][i] = incopy(hp->h_addr_list[i]);
        naddrs[0] = i;

        if (verbose)
            printf("Found %d address%s for %s\n",
                naddrs[0], plurale(naddrs[0]), nsname[0]);
        nservers = 1;
        return(TRUE);
    }

/*
 * Otherwise we have to find the nameservers for the zone.
 * These are supposed to be authoritative, but sometimes we
 * encounter lame delegations, perhaps due to misconfiguration.
 */
    if (!get_servers(name))
    {
        ns_error(name, T_NS, queryclass, server);
        nservers = 0;
        return(FALSE);
    }

/*
 * Usually we'll get addresses for all the servers in the additional
 * info section.  But in case we don't, look up their addresses.
 * Addresses could be missing because there is no room in the answer.
 * No address is present if the name of a server is not canonical.
 * If we get no addresses by extra query, and this is authoritative,
 * we flag a lame delegation to that server.
 */
    for (n = 0; n < nservers; n++)
    {
        if (naddrs[n] == 0)
        {
        hp = geth_byname(nsname[n]);
        if (hp != NULL)
        {
            for (i = 0; i < MAXIPADDR && hp->h_addr_list[i]; i++)
                ipaddr[n][i] = incopy(hp->h_addr_list[i]);
            naddrs[n] = i;
        }

        if (verbose)
            printf("Found %d address%s for %s by extra query\n",
                naddrs[n], plurale(naddrs[n]), nsname[n]);

        if (hp == NULL)
        {
            /* server name lookup failed */
            ns_error(nsname[n], T_A, C_IN, server);

            /* authoritative denial: probably misconfiguration */
            if (h_errno == NO_DATA || h_errno == HOST_NOT_FOUND)
            {
                if (server == NULL)
                    errmsg("%s has lame delegation to %s",
                        name, nsname[n]);
            }
        }

        if ((hp != NULL) && !sameword(hp->h_name, nsname[n]))
            pr_warning("%s nameserver %s is not canonical (%s)",
                name, nsname[n], hp->h_name);
        }
        else
        {
        if (verbose)
            printf("Found %d address%s for %s\n",
                naddrs[n], plurale(naddrs[n]), nsname[n]);
        }
    }

/*
 * Issue warning if only one server has been discovered.
 * This is not an error per se, but not much redundancy in that case.
 */
    if (nservers == 1)
        pr_warning("%s has only one nameserver %s",
            name, nsname[0]);

    return((nservers > 0) ? TRUE : FALSE);
}

/*
** GET_SERVERS -- Fetch names and addresses of authoritative servers
** -----------------------------------------------------------------
**
**    Returns:
**        TRUE if servers could be determined successfully.
**        FALSE otherwise.
**
**    Side effects:
**        The count of nameservers is stored in ``nservers''.
**        Names are stored in the nsname[] database.
**        Addresses are stored in the ipaddr[] database.
**        Address counts are stored in the naddrs[] database.
*/

bool
get_servers(name)
input char *name;            /* name of zone to find servers for */
{
    querybuf answer;
    register int n;
    bool result;            /* result status of action taken */

    if (verbose)
        printf("Finding nameservers for %s ...\n", name);

    n = get_info(&answer, name, T_NS, queryclass);
    if (n < 0)
        return(FALSE);

    if (verbose > 1)
        (void) print_info(&answer, n, name, T_NS, queryclass, FALSE);

    result = get_nsinfo(&answer, n, name);
    return(result);
}

/*
** GET_NSINFO -- Extract nameserver data from nameserver answer buffer
** -------------------------------------------------------------------
**
**    Returns:
**        TRUE if the answer buffer was processed successfully.
**        FALSE otherwise.
**
**    Outputs:
**        The count of nameservers is stored in ``nservers''.
**        Names are stored in the nsname[] database.
**        Addresses are stored in the ipaddr[] database.
**        Address counts are stored in the naddrs[] database.
*/

bool
get_nsinfo(answerbuf, answerlen, name)
input querybuf *answerbuf;        /* location of answer buffer */
input int answerlen;            /* length of answer buffer */
input char *name;            /* name of zone to find servers for */
{
    HEADER *bp;
    int qdcount, ancount, nscount, arcount, rrcount;
    u_char *msg, *eom;
    register u_char *cp;
    register int i;

    nservers = 0;            /* count of nameservers */

    bp = (HEADER *)answerbuf;
    qdcount = ntohs(bp->qdcount);
    ancount = ntohs(bp->ancount);
    nscount = ntohs(bp->nscount);
    arcount = ntohs(bp->arcount);

    msg = (u_char *)answerbuf;
    eom = (u_char *)answerbuf + answerlen;
    cp  = (u_char *)answerbuf + HFIXEDSZ;

    if (qdcount > 0 && cp < eom)    /* should be exactly one record */
    {
        cp = skip_qrec(name, T_NS, queryclass, cp, msg, eom);
        if (cp == NULL)
            return(FALSE);
        qdcount--;
    }

    if (qdcount)
    {
        pr_error("invalid qdcount after %s query for %s",
            pr_type(T_NS), name);
        h_errno = NO_RECOVERY;
        return(FALSE);
    }

/*
 * If the answer is authoritative, the names are found in the
 * answer section, and the nameserver section is empty.
 * If not, there may be duplicate names in both sections.
 * Addresses are found in the additional info section both cases.
 */
    rrcount = ancount + nscount + arcount;
    while (rrcount > 0 && cp < eom)
    {
        char rname[MAXDNAME+1];
        char dname[MAXDNAME+1];
        int type, class, ttl, dlen;
        u_char *eor;
        register int n;
        struct in_addr inaddr;

        n = expand_name(name, T_NONE, cp, msg, eom, rname);
        if (n < 0)
            return(FALSE);
        cp += n;

        n = 3*INT16SZ + INT32SZ;
        if (check_size(rname, T_NONE, cp, msg, eom, n) < 0)
            return(FALSE);

        type = _getshort(cp);
        cp += INT16SZ;

        class = _getshort(cp);
        cp += INT16SZ;

        ttl = _getlong(cp);
        cp += INT32SZ;

        dlen = _getshort(cp);
        cp += INT16SZ;

        eor = cp + dlen;
#ifdef lint
        if (verbose)
            printf("%-20s\t%d\t%s\t%s\n",
                rname, ttl, pr_class(class), pr_type(type));
#endif
        if ((type == T_NS) && sameword(rname, name))
        {
            n = expand_name(rname, type, cp, msg, eom, dname);
            if (n < 0)
                return(FALSE);
            cp += n;

            for (i = 0; i < nservers; i++)
                if (sameword(nsname[i], dname))
                    break;    /* duplicate */

            if (i >= nservers && nservers < MAXNSNAME)
            {
                (void) strcpy(nsname[nservers], dname);
                naddrs[nservers] = 0;
                nservers++;
            }
        }
        else if ((type == T_A) && (dlen == INADDRSZ))
        {
            for (i = 0; i < nservers; i++)
                if (sameword(nsname[i], rname))
                    break;    /* found */

            if (i < nservers && naddrs[i] < MAXIPADDR)
            {
                bcopy((char *)cp, (char *)&inaddr, INADDRSZ);
                ipaddr[i][naddrs[i]] = inaddr;
                naddrs[i]++;
            }

            cp += dlen;
        }
        else
        {
            /* just ignore other records */
            cp += dlen;
        }

        if (cp != eor)
        {
            pr_error("size error in %s record for %s, off by %s",
                pr_type(type), rname, itoa(cp - eor));
            h_errno = NO_RECOVERY;
            return(FALSE);
        }

        rrcount--;
    }

    if (rrcount)
    {
        pr_error("invalid rrcount after %s query for %s",
            pr_type(T_NS), name);
        h_errno = NO_RECOVERY;
        return(FALSE);
    }

    /* set proper status if no answers found */
    h_errno = (nservers > 0) ? 0 : TRY_AGAIN;
    return(TRUE);
}

/*
** SORT_SERVERS -- Sort set of nameservers according to preference
** ---------------------------------------------------------------
**
**    Returns:
**        None.
**
**    Inputs:
**        Set of nameservers as determined by find_servers().
**        The global variable ``prefserver'', if set, contains
**        a list of preferred server domains to compare against.
**
**    Outputs:
**        Stores the preferred nameserver order in nsrank[].
*/

void
sort_servers()
{
    register int i, j;
    register int n, pref;
    register char *p, *q;

/*
 * Initialize the default ranking.
 */
    for (n = 0; n < nservers; n++)
    {
        nsrank[n] = n;
        nspref[n] = 0;
    }

/*
 * Determine the nameserver preference.
 * Compare against a list of comma-separated preferred server domains.
 * Use the maximum value of all comparisons.
 */
    for (q = NULL, p = prefserver; p != NULL; p = q)
    {
        q = index(p, ',');
        if (q != NULL)
            *q = '\0';

        for (n = 0; n < nservers; n++)
        {
            pref = matchlabels(nsname[n], p);
            if (pref > nspref[n])
                nspref[n] = pref;
        }

        if (q != NULL)
            *q++ = ',';
    }

/*
 * Sort the set according to preference.
 * Keep the rest as much as possible in original order.
 */
    for (i = 0; i < nservers; i++)
    {
        for (j = i + 1; j < nservers; j++)
        {
            if (nspref[j] > nspref[i])
            {
                pref = nspref[j];
                /* nspref[j] = nspref[i]; */
                for (n = j; n > i; n--)
                    nspref[n] = nspref[n-1];
                nspref[i] = pref;

                pref = nsrank[j];
                /* nsrank[j] = nsrank[i]; */
                for (n = j; n > i; n--)
                    nsrank[n] = nsrank[n-1];
                nsrank[i] = pref;
            }
        }
    }
}

/*
** SKIP_TRANSFER -- Check whether a zone transfer should be skipped
** ----------------------------------------------------------------
**
**    Returns:
**        TRUE if a transfer for this zone should be skipped.
**        FALSE if the zone transfer should proceed.
**
**    Inputs:
**        The global variable ``skipzone'', if set, contains
**        a list of zone names to be skipped.
**
**    Certain zones are known to contain bogus information, and
**    can be requested to be excluded from further processing.
**    The zone transfer for such zones and its delegated zones
**    will be skipped.
*/

bool
skip_transfer(name)
input char *name;            /* name of zone to process */
{
    register char *p, *q;
    bool skip = FALSE;

    for (q = NULL, p = skipzone; p != NULL; p = q)
    {
        q = index(p, ',');
        if (q != NULL)
            *q = '\0';

        if (sameword(name, p))
            skip = TRUE;

        if (q != NULL)
            *q++ = ',';
    }

    return(skip);
}

/*
** DO_CHECK -- Check SOA records at each of the nameservers
** --------------------------------------------------------
**
**    Returns:
**        None.
**
**    Inputs:
**        The count of nameservers is stored in ``nservers''.
**        Names are stored in the nsname[] database.
**        Addresses are stored in the ipaddr[] database.
**        Address counts are stored in the naddrs[] database.
**
**    The SOA record of the zone is checked at each nameserver.
**    Nameserver recursion is turned off to make sure that the
**    answer is authoritative.
*/

void
do_check(name)
input char *name;            /* name of zone to process */
{
    res_state_t save_res;        /* saved copy of resolver database */
    char *save_server;        /* saved copy of server name */
    register int n;
    register int i;

    /* save resolver database */
    save_res = _res;
    save_server = server;

    /* turn off nameserver recursion */
    _res.options &= ~RES_RECURSE;

    for (n = 0; n < nservers; n++)
    {
        if (naddrs[n] < 1)
            continue;    /* shortcut */

        server = nsname[n];
        for (i = 0; i < MAXNS && i < naddrs[n]; i++)
        {
            nslist(i).sin_family = AF_INET;
            nslist(i).sin_port = htons(NAMESERVER_PORT);
            nslist(i).sin_addr = ipaddr[n][i];
        }
        _res.nscount = i;

        /* retrieve and check SOA */
        if (check_zone(name))
            continue;

        /* SOA query failed */
        ns_error(name, T_SOA, queryclass, server);

        /* explicit server failure: possibly data expired */
        lameserver = (h_errno == SERVER_FAILURE) ? TRUE : FALSE;

        /* non-authoritative denial: assume lame delegation */
        if (h_errno == NO_RREC || h_errno == NO_HOST)
            lameserver = TRUE;

        /* authoritative denial: probably misconfiguration */
        if (h_errno == NO_DATA || h_errno == HOST_NOT_FOUND)
            lameserver = TRUE;

        /* flag an error if server should not have failed */
        if (lameserver && authserver)
            errmsg("%s has lame delegation to %s",
                name, server);
    }

    /* restore resolver database */
    _res = save_res;
    server = save_server;
}

/*
** DO_TRANSFER -- Perform a zone transfer from any of its nameservers
** ------------------------------------------------------------------
**
**    Returns:
**        TRUE if the zone data have been retrieved successfully.
**        FALSE if none of the servers responded.
**
**    Inputs:
**        The count of nameservers is stored in ``nservers''.
**        Names are stored in the nsname[] database.
**        Addresses are stored in the ipaddr[] database.
**        Address counts are stored in the naddrs[] database.
**
**    Ask zone transfer to the nameservers, until one responds.
**    The list of nameservers is sorted according to preference.
**    An authoritative server should always respond positively.
**    If it responds with an error, we may have a lame delegation.
**    Always retry with the next server to avoid missing entire zones.
*/

bool
do_transfer(name)
input char *name;            /* name of zone to do zone xfer for */
{
    register int n, ns;
    register int i;

    for (sort_servers(), ns = 0; ns < nservers; ns++)
    {
        for (n = nsrank[ns], i = 0; i < naddrs[n]; i++)
        {
        if (verbose)
            printf("Trying server %s (%s) ...\n",
                inet_ntoa(ipaddr[n][i]), nsname[n]);

        if (transfer_zone(name, ipaddr[n][i], nsname[n]))
            goto done;    /* double break */

        /* zone transfer failed */
        if ((h_errno != TRY_AGAIN) || verbose)
            ns_error(name, T_AXFR, queryclass, nsname[n]);

        /* zone transfer request was explicitly refused */
        if (h_errno == QUERY_REFUSED)
            break;

        /* explicit server failure: possibly data expired */
        lameserver = (h_errno == SERVER_FAILURE) ? TRUE : FALSE;

        /* non-authoritative denial: assume lame delegation */
        if (h_errno == NO_RREC || h_errno == NO_HOST)
            lameserver = TRUE;

        /* authoritative denial: probably misconfiguration */
        if (h_errno == NO_DATA || h_errno == HOST_NOT_FOUND)
            lameserver = TRUE;

        /* flag an error if server should not have failed */
        if (lameserver && authserver)
            errmsg("%s has lame delegation to %s",
                name, nsname[n]);

        /* try next server if this one is sick */
        if (lameserver)
            break;

        /* terminate on irrecoverable errors */
        if (h_errno != TRY_AGAIN)
            return(FALSE);

        /* in case nameserver not present */
        if (errno == ECONNREFUSED)
            break;
        }
    }
done:
    if (ns >= nservers)
    {
        if ((h_errno == TRY_AGAIN) && !verbose)
            ns_error(name, T_AXFR, queryclass, (char *)NULL);
        errmsg("No nameservers for %s responded", name);
        return(FALSE);
    }

    return(TRUE);
}

/*
** TRANSFER_ZONE -- Wrapper for get_zone() to hide administrative tasks
** --------------------------------------------------------------------
**
**    Returns:
**        See get_zone() for details.
**
**    Side effects:
**        See get_zone() for details.
**
**    This routine may be called repeatedly with different server
**    addresses, until one of the servers responds. Various items
**    must be reset on every try to continue with a clean slate.
*/

bool
transfer_zone(name, inaddr, host)
input char *name;            /* name of zone to do zone xfer for */
input struct in_addr inaddr;        /* address of server to be queried */
input char *host;            /* name of server to be queried */
{
    register int n;

/*
 * Reset the resource record statistics before each try.
 */
    clear_statistics();

/*
 * Reset the hash tables of saved resource record information.
 * These tables are used only during the zone transfer itself.
 */
    clear_ttltab();
    clear_hosttab();
    clear_zonetab();

/*
 * Perform the actual zone transfer.
 * All error reporting is done by get_zone().
 */
    if (get_zone(name, inaddr, host))
        return(TRUE);

/*
 * Failure to get the zone. Free any memory that may have been allocated.
 * On success it is the responsibility of the caller to free the memory.
 * The information gathered is used by list_zone() after the zone transfer.
 */
    for (n = 0; n < hostcount; n++)
        xfree(hostname(n));

    for (n = 0; n < zonecount; n++)
        xfree(zonename[n]);

    if (zonename != NULL)
        xfree(zonename);

    zonename = NULL;

    return(FALSE);
}

/*
** GET_ZONE -- Perform a zone transfer from server at specific address
** -------------------------------------------------------------------
**
**    Returns:
**        TRUE if the zone data have been retrieved successfully.
**        FALSE if an error occurred (h_errno is set appropriately).
**        Set TRY_AGAIN wherever possible to try the next server.
**
**    Side effects:
**        Stores list of delegated zones found in zonename[],
**        and the count of delegated zones in ``zonecount''.
**        Stores list of host names found in hostname[],
**        and the count of host names in ``hostcount''.
**        Updates resource record statistics in record_stats[].
**        This array must have been cleared before.
*/

bool
get_zone(name, inaddr, host)
input char *name;            /* name of zone to do zone xfer for */
input struct in_addr inaddr;        /* address of server to be queried */
input char *host;            /* name of server to be queried */
{
    querybuf query;
    querybuf answer;
    HEADER *bp;
    int ancount;
    int sock;
    struct sockaddr_in sin;
    register int n, i;
    int nrecords = 0;        /* number of records processed */
    int npackets = 0;        /* number of packets received */

    /* clear global counts */
    soacount = 0;            /* count of SOA records */
    zonecount = 0;            /* count of delegated zones */
    hostcount = 0;            /* count of host names */

/*
 * Construct query, and connect to the given server.
 */
    errno = 0;    /* reset before querying nameserver */

    n = res_mkquery(QUERY, name, queryclass, T_AXFR, (qbuf_t *)NULL, 0,
            (rrec_t *)NULL, (qbuf_t *)&query, sizeof(querybuf));
    if (n < 0)
    {
        if (debug)
            printf("%sres_mkquery failed\n", dbprefix);
        h_errno = NO_RECOVERY;
        return(FALSE);
    }

    if (debug)
    {
        printf("%sget_zone()\n", dbprefix);
        pr_query((qbuf_t *)&query, n, stdout);
    }

    /* setup destination address */
    bzero((char *)&sin, sizeof(sin));

    sin.sin_family = AF_INET;
    sin.sin_port = htons(NAMESERVER_PORT);
    sin.sin_addr = inaddr;

    sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock < 0)
    {
        _res_perror(&sin, host, "socket");
        h_errno = TRY_AGAIN;
        return(FALSE);
    }

    if (_res_connect(sock, &sin, sizeof(sin)) < 0)
    {
        if (verbose || debug)
            _res_perror(&sin, host, "connect");
        (void) close(sock);
        h_errno = TRY_AGAIN;
        return(FALSE);
    }

    if (verbose)
        printf("Asking zone transfer for %s ...\n", name);

/*
 * Send the query buffer.
 */
    if (_res_write(sock, &sin, host, (char *)&query, n) < 0)
    {
        (void) close(sock);
        h_errno = TRY_AGAIN;
        return(FALSE);
    }

/*
 * Process all incoming packets, usually one record in a separate packet.
 */
    while ((n = _res_read(sock, &sin, host, (char *)&answer, sizeof(querybuf))) != 0)
    {
        if (n < 0)
        {
            (void) close(sock);
            h_errno = TRY_AGAIN;
            return(FALSE);
        }

        errno = 0;    /* reset after we got an answer */

        if (n < HFIXEDSZ)
        {
            pr_error("answer length %s too short during %s for %s from %s",
                itoa(n), pr_type(T_AXFR), name, host);
            (void) close(sock);
            h_errno = TRY_AGAIN;
            return(FALSE);
        }

        if (debug > 1)
        {
            printf("%sgot answer, %d bytes:\n", dbprefix, n);
            pr_query((qbuf_t *)&answer, querysize(n), stdout);
        }

    /*
     * Analyze the contents of the answer and check for errors.
     * An error can be expected only in the very first packet.
     * The query section should be empty except in the first packet.
     * Note the special error status codes for specific failures.
     */
        bp = (HEADER *)&answer;
        ancount = ntohs(bp->ancount);

        if (bp->rcode != NOERROR || ancount == 0)
        {
            if (verbose || debug)
                print_status(&answer, n);

            switch (bp->rcode)
            {
                case NXDOMAIN:
                /* distinguish between authoritative or not */
                h_errno = bp->aa ? HOST_NOT_FOUND : NO_HOST;
                break;

                case NOERROR:
                /* distinguish between authoritative or not */
                h_errno = bp->aa ? NO_DATA : NO_RREC;
                break;

                case REFUSED:
                /* special status if zone transfer refused */
                h_errno = QUERY_REFUSED;
                break;

                case SERVFAIL:
                /* special status upon explicit failure */
                h_errno = SERVER_FAILURE;
                break;

                default:
                /* all other errors will cause a retry */
                h_errno = TRY_AGAIN;
                break;
            }

            if (npackets != 0)
                pr_error("unexpected error during %s for %s from %s",
                    pr_type(T_AXFR), name, host);

            (void) close(sock);
            return(FALSE);
        }

        /* valid answer received, avoid buffer overrun */
        h_errno = 0;
        n = querysize(n);

    /*
     * The nameserver and additional info section should be empty.
     * There may be multiple answers in the answer section.
     */
#ifdef obsolete
        if (ancount > 1)
            pr_error("multiple answers during %s for %s from %s",
                pr_type(T_AXFR), name, host);
#endif
        if (ntohs(bp->nscount) != 0)
            pr_error("nonzero nscount during %s for %s from %s",
                pr_type(T_AXFR), name, host);

        if (ntohs(bp->arcount) != 0)
            pr_error("nonzero arcount during %s for %s from %s",
                pr_type(T_AXFR), name, host);

    /*
     * Valid packet received. Print contents if appropriate.
     * Specific zone information will be saved by update_zone().
     */
        npackets += 1;
        nrecords += ancount;

        soaname = NULL, subname = NULL, adrname = NULL, address = 0;
        listhost = host;

        (void) print_info(&answer, n, name, T_AXFR, queryclass, FALSE);

    /*
     * Terminate upon the second SOA record for this zone.
     */
        if (soacount > 1)
            break;
    }

/*
 * End of zone transfer at second SOA record or zero length read.
 */
    (void) close(sock);

/*
 * Check for the anomaly that the whole transfer consisted of the
 * SOA records only. Could occur if we queried the victim of a lame
 * delegation which happened to have the SOA record present.
 */
    if (nrecords <= soacount)
    {
        pr_error("empty zone transfer for %s from %s",
            name, host);
        h_errno = NO_RREC;
        return(FALSE);
    }

/*
 * Do an extra check for delegated zones that also have an A record.
 * Those may have been defined in the child zone, and crept in the
 * parent zone, or may have been defined as glue records.
 * This is not necessarily an error, but the host count may be wrong.
 * Note that an A record for the current zone has been ignored above.
 */
    for (n = 0; n < zonecount; n++)
    {
        i = host_index(zonename[n], FALSE);
#ifdef obsolete
        for (i = 0; i < hostcount; i++)
            if (sameword(hostname(i), zonename[n]))
                break;    /* found */
#endif
        if (i < hostcount)
            pr_warning("%s has both NS and A records within %s from %s",
                zonename[n], name, host);
    }

/*
 * The zone transfer has been successful.
 */
    if (verbose)
    {
        printf("Transfer complete, %d record%s received for %s\n",
            nrecords, plural(nrecords), name);
        if (npackets != nrecords)
            printf("Transfer consisted of %d packet%s from %s\n",
                npackets, plural(npackets), host);
    }

    return(TRUE);
}

/*
** UPDATE_ZONE -- Save zone information during zone listings
** ---------------------------------------------------------
**
**    Returns:
**        None.
**
**    Side effects:
**        Stores list of delegated zones found in zonename[],
**        and the count of delegated zones in ``zonecount''.
**        Stores list of host names found in hostname[],
**        and the count of host names in ``hostcount''.
**        Stores the count of SOA records in ``soacount''.
**
**    This routine is called by print_info() for each resource record.
*/

void
update_zone(name)
input char *name;            /* name of zone to do zone xfer for */
{
    char *host = listhost;        /* contacted host for zone listings */
    register int i;

/*
 * Terminate upon the second SOA record for this zone.
 */
    if (soaname && sameword(soaname, name))
        soacount++;

    /* the nameserver balks on this one */
    else if (soaname && !sameword(soaname, name))
        pr_warning("extraneous SOA record for %s within %s from %s",
            soaname, name, host);

/*
 * Save encountered delegated zone name for recursive listing.
 */
    if (subname && indomain(subname, name, FALSE))
    {
        i = zone_index(subname, TRUE);
#ifdef obsolete
        for (i = 0; i < zonecount; i++)
            if (sameword(zonename[i], subname))
                break;    /* duplicate */
#endif
        if (i >= zonecount)
        {
            zonename = newlist(zonename, zonecount+1, char *);
            zonename[zonecount] = newstr(subname);
            zonecount++;
        }
    }

    /* warn about strange delegated zones */
    else if (subname && !indomain(subname, name, TRUE))
        pr_warning("extraneous NS record for %s within %s from %s",
            subname, name, host);

/*
 * Save encountered name of A record for host name count.
 */
    if (adrname && indomain(adrname, name, FALSE) && !reverse)
    {
        i = host_index(adrname, TRUE);
#ifdef obsolete
        for (i = 0; i < hostcount; i++)
            if (sameword(hostname(i), adrname))
                break;    /* duplicate */
#endif
        if (i >= hostcount)
        {
            if (hostcount >= maxhosts)
            {
                maxhosts += MAXHOSTINCR;
                hostlist = newlist(hostlist, maxhosts, host_data_t);
            }
            hostname(hostcount) = newstr(adrname);
            hostaddr(hostcount) = address;
            multaddr(hostcount) = FALSE;
            hostcount++;
        }
        else if (address != hostaddr(i))
            multaddr(i) = TRUE;
    }

    /* check for unauthoritative glue records */
    else if (adrname && !indomain(adrname, name, TRUE))
        pr_warning("extraneous glue record for %s within %s from %s",
            adrname, name, host);
}

/*
** GET_MXREC -- Fetch MX records of a domain
** -----------------------------------------
**
**    Returns:
**        TRUE if MX records were found.
**        FALSE otherwise.
*/

bool
get_mxrec(name)
input char *name;            /* domain name to get mx for */
{
    querybuf answer;
    register int n;

    if (verbose)
        printf("Finding MX records for %s ...\n", name);

    n = get_info(&answer, name, T_MX, queryclass);
    if (n < 0)
        return(FALSE);

    (void) print_info(&answer, n, name, T_MX, queryclass, FALSE);

    return(TRUE);
}

/*
** GET_PRIMARY -- Fetch name of primary nameserver for a zone
** ----------------------------------------------------------
**
**    Returns:
**        Pointer to the name of the primary server, if found.
**        NULL if the server could not be determined.
*/

char *
get_primary(name)
input char *name;            /* name of zone to get soa for */
{
    querybuf answer;
    register int n;

    if (verbose)
        printf("Finding primary nameserver for %s ...\n", name);

    n = get_info(&answer, name, T_SOA, queryclass);
    if (n < 0)
        return(NULL);

    if (verbose > 1)
        (void) print_info(&answer, n, name, T_SOA, queryclass, FALSE);

    soaname = NULL;
    (void) get_soainfo(&answer, n, name);
    if (soaname == NULL)
        return(NULL);

    return(soa.primary);
}

/*
** CHECK_ZONE -- Fetch and analyze SOA record of a zone
** ----------------------------------------------------
**
**    Returns:
**        TRUE if the SOA record was found at the given server.
**        FALSE otherwise.
**
**    Inputs:
**        The global variable ``server'' must contain the name
**        of the server that was queried.
*/

bool
check_zone(name)
input char *name;            /* name of zone to get soa for */
{
    querybuf answer;
    register int n;

    if (verbose)
        printf("Checking SOA for %s at server %s ...\n", name, server);
    else if (authserver)
        printf("%-20s\tNS\t%s\n", name, server);
    else
        printf("%s\t(%s)\n", name, server);

    n = get_info(&answer, name, T_SOA, queryclass);
    if (n < 0)
        return(FALSE);

    if (verbose > 1)
        (void) print_info(&answer, n, name, T_SOA, queryclass, FALSE);

    soaname = NULL;
    (void) get_soainfo(&answer, n, name);
    if (soaname == NULL)
        return(FALSE);

    check_soa(&answer, name);

    return(TRUE);
}

/*
** GET_SOAINFO -- Extract SOA data from nameserver answer buffer
** -------------------------------------------------------------
**
**    Returns:
**        TRUE if the answer buffer was processed successfully.
**        FALSE otherwise.
**
**    Outputs:
**        The global struct ``soa'' is filled with the soa data.
**
**    Side effects:
**        Sets ``soaname'' if there is a valid SOA record.
**        This variable must have been cleared before calling
**        get_soainfo() and may be checked afterwards.
*/

bool
get_soainfo(answerbuf, answerlen, name)
input querybuf *answerbuf;        /* location of answer buffer */
input int answerlen;            /* length of answer buffer */
input char *name;            /* name of zone to get soa for */
{
    HEADER *bp;
    int qdcount, ancount;
    u_char *msg, *eom;
    register u_char *cp;

    bp = (HEADER *)answerbuf;
    qdcount = ntohs(bp->qdcount);
    ancount = ntohs(bp->ancount);

    msg = (u_char *)answerbuf;
    eom = (u_char *)answerbuf + answerlen;
    cp  = (u_char *)answerbuf + HFIXEDSZ;

    if (qdcount > 0 && cp < eom)    /* should be exactly one record */
    {
        cp = skip_qrec(name, T_SOA, queryclass, cp, msg, eom);
        if (cp == NULL)
            return(FALSE);
        qdcount--;
    }

    if (qdcount)
    {
        pr_error("invalid qdcount after %s query for %s",
            pr_type(T_SOA), name);
        h_errno = NO_RECOVERY;
        return(FALSE);
    }

/*
 * Check answer section only.
 * Check that answers match the requested zone. Ignore other entries.
 * The nameserver section may contain the nameservers for the zone,
 * and the additional section their addresses, but not guaranteed.
 * Those sections are usually empty for authoritative answers.
 */
    while (ancount > 0 && cp < eom)
    {
        char rname[MAXDNAME+1];
        int type, class, ttl, dlen;
        u_char *eor;
        register int n;

        n = expand_name(name, T_NONE, cp, msg, eom, rname);
        if (n < 0)
            return(FALSE);
        cp += n;

        n = 3*INT16SZ + INT32SZ;
        if (check_size(rname, T_NONE, cp, msg, eom, n) < 0)
            return(FALSE);

        type = _getshort(cp);
        cp += INT16SZ;

        class = _getshort(cp);
        cp += INT16SZ;

        ttl = _getlong(cp);
        cp += INT32SZ;

        dlen = _getshort(cp);
        cp += INT16SZ;

        eor = cp + dlen;
#ifdef lint
        if (verbose)
            printf("%-20s\t%d\t%s\t%s\n",
                rname, ttl, pr_class(class), pr_type(type));
#endif
        if ((type == T_SOA) && sameword(rname, name))
        {
            n = expand_name(rname, type, cp, msg, eom, soa.primary);
            if (n < 0)
                return(FALSE);
            cp += n;

            n = expand_name(rname, type, cp, msg, eom, soa.hostmaster);
            if (n < 0)
                return(FALSE);
            cp += n;

            n = 5*INT32SZ;
            if (check_size(rname, type, cp, msg, eor, n) < 0)
                return(FALSE);
            soa.serial = _getlong(cp);
            cp += INT32SZ;
            soa.refresh = _getlong(cp);
            cp += INT32SZ;
            soa.retry = _getlong(cp);
            cp += INT32SZ;
            soa.expire = _getlong(cp);
            cp += INT32SZ;
            soa.defttl = _getlong(cp);
            cp += INT32SZ;

            /* valid complete soa record found */
            soaname = strcpy(soanamebuf, rname);
        }
        else
        {
            /* just ignore other records */
            cp += dlen;
        }

        if (cp != eor)
        {
            pr_error("size error in %s record for %s, off by %s",
                pr_type(type), rname, itoa(cp - eor));
            h_errno = NO_RECOVERY;
            return(FALSE);
        }

        ancount--;
    }

    if (ancount)
    {
        pr_error("invalid ancount after %s query for %s",
            pr_type(T_SOA), name);
        h_errno = NO_RECOVERY;
        return(FALSE);
    }

    /* set proper status if no answers found */
    h_errno = (soaname != NULL) ? 0 : TRY_AGAIN;
    return(TRUE);
}

/*
** CHECK_SOA -- Analyze retrieved SOA records of a zone
** ----------------------------------------------------
**
**    Returns:
**        None.
**
**    Inputs:
**        The global variable ``server'' must contain the
**        name of the server that was queried.
**        The global struct ``soa'' must contain the soa data.
*/

void
check_soa(answerbuf, name)
input querybuf *answerbuf;        /* location of answer buffer */
input char *name;            /* name of zone to check soa for */
{
    static char oldnamebuf[MAXDNAME+1];
    static char *oldname = NULL;    /* previous name of zone */
    static char *oldserver = NULL;    /* previous name of server */
    static soa_data_t oldsoa;    /* previous soa data */
    register int n;
    HEADER *bp;

/*
 * Print the various SOA fields in abbreviated form.
 * Values are actually unsigned, but we print them as signed integers,
 * apart from the serial which really becomes that big sometimes.
 * In the latter case we print a warning below.
 */
    printf("%s\t%s\t(%u %d %d %d %d)\n",
        soa.primary, soa.hostmaster, (unsigned)soa.serial,
        soa.refresh, soa.retry, soa.expire, soa.defttl);

/*
 * We are supposed to have queried an authoritative nameserver, and since
 * nameserver recursion has been turned off, answer must be authoritative.
 */
    bp = (HEADER *)answerbuf;
    if (!bp->aa)
    {
        if (authserver)
            pr_error("%s SOA record at %s is not authoritative",
                name, server);
        else
            pr_warning("%s SOA record at %s is not authoritative",
                name, server);

        if (authserver)
            errmsg("%s has lame delegation to %s",
                name, server);
    }

/*
 * Check whether we are switching to a new zone.
 * The old name must have been saved in static storage.
 */
    if ((oldname != NULL) && !sameword(name, oldname))
        oldname = NULL;

/*
 * Make few timer consistency checks only for the first one in a series.
 * Compare the primary field against the list of authoritative servers.
 * Explicitly check the hostmaster field for illegal characters ('@').
 * Yell if the serial has the high bit set (not always intentional).
 */
    if (oldname == NULL)
    {
        for (n = 0; n < nservers; n++)
            if (sameword(soa.primary, nsname[n]))
                break;    /* found */

        if ((n >= nservers) && authserver)
            pr_warning("%s SOA primary %s is not advertised via NS",
                name, soa.primary);

        if (!valid_name(soa.primary, FALSE, FALSE, FALSE))
            pr_warning("%s SOA primary %s has illegal name",
                name, soa.primary);

        if (!valid_name(soa.hostmaster, FALSE, TRUE, FALSE))
            pr_warning("%s SOA hostmaster %s has illegal mailbox",
                name, soa.hostmaster);

        if (bitset(0x80000000, soa.serial))
            pr_warning("%s SOA serial has high bit set",
                name);

        if (soa.retry > soa.refresh)
            pr_warning("%s SOA retry exceeds refresh",
                name);

        if (soa.refresh + soa.retry > soa.expire)
            pr_warning("%s SOA refresh+retry exceeds expire",
                name);
    }

/*
 * Compare various fields with those of the previous query, if any.
 * Different serial numbers may be present if secondaries have not yet
 * refreshed the data from the primary. Issue only a warning in that case.
 */
    if (oldname != NULL)
    {
        if (!sameword(soa.primary, oldsoa.primary))
            pr_error("%s and %s have different primary for %s",
                server, oldserver, name);

        if (!sameword(soa.hostmaster, oldsoa.hostmaster))
            pr_error("%s and %s have different hostmaster for %s",
                server, oldserver, name);

        if (soa.serial != oldsoa.serial)
            pr_warning("%s and %s have different serial for %s",
                server, oldserver, name);

        if (soa.refresh != oldsoa.refresh)
            pr_error("%s and %s have different refresh for %s",
                server, oldserver, name);

        if (soa.retry != oldsoa.retry)
            pr_error("%s and %s have different retry for %s",
                server, oldserver, name);

        if (soa.expire != oldsoa.expire)
            pr_error("%s and %s have different expire for %s",
                server, oldserver, name);

        if (soa.defttl != oldsoa.defttl)
            pr_error("%s and %s have different defttl for %s",
                server, oldserver, name);
    }

/*
 * Save the current information.
 */
    oldname = strcpy(oldnamebuf, name);
    oldserver = server;
    oldsoa = soa;
}

/*
** CHECK_DUPL -- Check global address list for duplicates
** ------------------------------------------------------
**
**    Returns:
**        TRUE if the given host address already exists.
**        FALSE otherwise.
**
**    Side effects:
**        Adds the host address to the list if not present.
**
**    The information in this table is global, and is not cleared.
*/

#define AHASHSIZE    0x2000
#define AHASHMASK    0x1fff

typedef struct addr_tab {
    ipaddr_t *addrlist;        /* global list of addresses */
    int addrcount;            /* count of global addresses */
} addr_tab_t;

addr_tab_t addrtab[AHASHSIZE];        /* hash list of global addresses */

bool
check_dupl(addr)
input ipaddr_t addr;            /* address of host to check */
{
     register int i;
    register addr_tab_t *s;

    s = &addrtab[ntohl(addr) & AHASHMASK];

    for (i = 0; i < s->addrcount; i++)
        if (s->addrlist[i] == addr)
            return(TRUE);    /* duplicate */

    s->addrlist = newlist(s->addrlist, s->addrcount+1, ipaddr_t);
    s->addrlist[s->addrcount] = addr;
    s->addrcount++;
    return(FALSE);
}

/*
** CHECK_TTL -- Check list of records for different ttl values
** -----------------------------------------------------------
**
**    Returns:
**        TRUE if the ttl value matches the first record
**        already listed with the same name/type/class.
**        FALSE only when the first discrepancy is found.
**
**    Side effects:
**        Adds the record data to the list if not present.
*/

#define THASHSIZE    2003

typedef struct ttl_tab {
    struct ttl_tab *next;        /* next entry in chain */
    char *name;            /* name of resource record */
    int type;            /* resource record type */
    int class;            /* resource record class */
    int ttl;            /* time_to_live value */
    int count;            /* count of different ttl values */
} ttl_tab_t;

ttl_tab_t *ttltab[THASHSIZE];        /* hash list of record info */

bool
check_ttl(name, type, class, ttl)
input char *name;            /* resource record name */
input int type, class, ttl;        /* resource record fixed values */
{
    register ttl_tab_t *s;
    register ttl_tab_t **ps;
    register unsigned int hfunc;
    register char *p;
    register char c;

/*
 * Compute the hash function for this resource record.
 * Look it up in the appropriate hash chain.
 */
    for (hfunc = type, p = name; (c = *p) != '\0'; p++)
    {
        hfunc = ((hfunc << 1) ^ (lowercase(c) & 0377)) % THASHSIZE;
    }

    for (ps = &ttltab[hfunc]; (s = *ps) != NULL; ps = &s->next)
    {
        if (s->type != type || s->class != class)
            continue;
        if (sameword(s->name, name))
            break;
    }

/*
 * Allocate new entry if not found.
 */
    if (s == NULL)
    {
        /* ps = &ttltab[hfunc]; */
        s = newstruct(ttl_tab_t);

        /* initialize new entry */
        s->name = newstr(name);
        s->type = type;
        s->class = class;
        s->ttl = ttl;
        s->count = 0;

        /* link it in */
        s->next = *ps;
        *ps = s;
    }

/*
 * Check whether the ttl value matches the first recorded one.
 * If not, signal only the first discrepancy encountered, so
 * only one warning message will be printed.
 */
    if (s->ttl == ttl)
        return(TRUE);

    s->count += 1;
    return((s->count == 1) ? FALSE : TRUE);
}

/*
** CLEAR_TTLTAB -- Clear resource record list for ttl checking
** -----------------------------------------------------------
**
**    Returns:
**        None.
**
**    An entry on the hash list, and the host name in each
**    entry, have been allocated in dynamic memory.
**
**    The information in this table is on a per-zone basis.
**    It must be cleared before any subsequent zone transfers.
*/

void
clear_ttltab()
{
    register int i;
    register ttl_tab_t *s, *t;

    for (i = 0; i < THASHSIZE; i++)
    {
        if (ttltab[i] != NULL)
        {
            /* free chain of entries */
            for (t = NULL, s = ttltab[i]; s != NULL; s = t)
            {
                t = s->next;
                xfree(s->name);
                xfree(s);
            }

            /* reset hash chain */
            ttltab[i] = NULL;
        }
    }
}

/*
** HOST_INDEX -- Check list of host names for name being present
** -------------------------------------------------------------
**
**    Returns:
**        Index into hostname[] table, if found.
**        Current ``hostcount'' value, if not found.
**
**    Side effects:
**        May add an entry to the hash list if not present.
**
**    A linear search through the master table becomes very
**    costly for zones with more than a few thousand hosts.
**    Maintain a hash list with indexes into the master table.
**    Caller should update the master table after this call.
*/

#define HHASHSIZE    2003

typedef struct host_tab {
    struct host_tab *next;        /* next entry in chain */
    int slot;            /* slot in host name table */
} host_tab_t;

host_tab_t *hosttab[HHASHSIZE];        /* hash list of host name info */

int
host_index(name, enter)
input char *name;            /* the host name to check */
input bool enter;            /* add to table if not found */
{
    register host_tab_t *s;
    register host_tab_t **ps;
    register unsigned int hfunc;
    register char *p;
    register char c;

/*
 * Compute the hash function for this host name.
 * Look it up in the appropriate hash chain.
 */
    for (hfunc = 0, p = name; (c = *p) != '\0'; p++)
    {
        hfunc = ((hfunc << 1) ^ (lowercase(c) & 0377)) % HHASHSIZE;
    }

    for (ps = &hosttab[hfunc]; (s = *ps) != NULL; ps = &s->next)
    {
        if (s->slot >= hostcount)
            continue;
        if (sameword(hostname(s->slot), name))
            break;
    }

/*
 * Allocate new entry if not found.
 */
    if ((s == NULL) && enter)
    {
        /* ps = &hosttab[hfunc]; */
        s = newstruct(host_tab_t);

        /* initialize new entry */
        s->slot = hostcount;

        /* link it in */
        s->next = *ps;
        *ps = s;
    }

    return((s != NULL) ? s->slot : hostcount);
}

/*
** CLEAR_HOSTTAB -- Clear hash list for host name checking
** -------------------------------------------------------
**
**    Returns:
**        None.
**
**    A hash list entry has been allocated in dynamic memory.
**
**    The information in this table is on a per-zone basis.
**    It must be cleared before any subsequent zone transfers.
*/

void
clear_hosttab()
{
    register int i;
    register host_tab_t *s, *t;

    for (i = 0; i < HHASHSIZE; i++)
    {
        if (hosttab[i] != NULL)
        {
            /* free chain of entries */
            for (t = NULL, s = hosttab[i]; s != NULL; s = t)
            {
                t = s->next;
                xfree(s);
            }

            /* reset hash chain */
            hosttab[i] = NULL;
        }
    }
}

/*
** ZONE_INDEX -- Check list of zone names for name being present
** -------------------------------------------------------------
**
**    Returns:
**        Index into zonename[] table, if found.
**        Current ``zonecount'' value, if not found.
**
**    Side effects:
**        May add an entry to the hash list if not present.
**
**    A linear search through the master table becomes very
**    costly for more than a few thousand delegated zones.
**    Maintain a hash list with indexes into the master table.
**    Caller should update the master table after this call.
*/

#define ZHASHSIZE    2003

typedef struct zone_tab {
    struct zone_tab *next;        /* next entry in chain */
    int slot;            /* slot in zone name table */
} zone_tab_t;

zone_tab_t *zonetab[ZHASHSIZE];        /* hash list of zone name info */

int
zone_index(name, enter)
input char *name;            /* the zone name to check */
input bool enter;            /* add to table if not found */
{
    register zone_tab_t *s;
    register zone_tab_t **ps;
    register unsigned int hfunc;
    register char *p;
    register char c;

/*
 * Compute the hash function for this zone name.
 * Look it up in the appropriate hash chain.
 */
    for (hfunc = 0, p = name; (c = *p) != '\0'; p++)
    {
        hfunc = ((hfunc << 1) ^ (lowercase(c) & 0377)) % ZHASHSIZE;
    }

    for (ps = &zonetab[hfunc]; (s = *ps) != NULL; ps = &s->next)
    {
        if (s->slot >= zonecount)
            continue;
        if (sameword(zonename[s->slot], name))
            break;
    }

/*
 * Allocate new entry if not found.
 */
    if ((s == NULL) && enter)
    {
        /* ps = &zonetab[hfunc]; */
        s = newstruct(zone_tab_t);

        /* initialize new entry */
        s->slot = zonecount;

        /* link it in */
        s->next = *ps;
        *ps = s;
    }

    return((s != NULL) ? s->slot : zonecount);
}

/*
** CLEAR_ZONETAB -- Clear hash list for zone name checking
** -------------------------------------------------------
**
**    Returns:
**        None.
**
**    A hash list entry has been allocated in dynamic memory.
**
**    The information in this table is on a per-zone basis.
**    It must be cleared before any subsequent zone transfers.
*/

void
clear_zonetab()
{
    register int i;
    register zone_tab_t *s, *t;

    for (i = 0; i < ZHASHSIZE; i++)
    {
        if (zonetab[i] != NULL)
        {
            /* free chain of entries */
            for (t = NULL, s = zonetab[i]; s != NULL; s = t)
            {
                t = s->next;
                xfree(s);
            }

            /* reset hash chain */
            zonetab[i] = NULL;
        }
    }
}

/*
** CHECK_CANON -- Check list of domain names for name being canonical
** ------------------------------------------------------------------
**
**    Returns:
**        Nonzero if the name is definitely not canonical.
**        0 if it is canonical, or if it remains undecided.
**
**    Side effects:
**        Adds the domain name to the list if not present.
**
**    The information in this table is global, and is not cleared
**    (which may be necessary if the checking algorithm changes).
*/

#define CHASHSIZE    2003

typedef struct canon_tab {
    struct canon_tab *next;        /* next entry in chain */
    char *name;            /* domain name */
    int status;            /* nonzero if not canonical */
} canon_tab_t;

canon_tab_t *canontab[CHASHSIZE];    /* hash list of domain name info */

int
check_canon(name)
input char *name;            /* the domain name to check */
{
    register canon_tab_t *s;
    register canon_tab_t **ps;
    register unsigned int hfunc;
    register char *p;
    register char c;

/*
 * Compute the hash function for this domain name.
 * Look it up in the appropriate hash chain.
 */
    for (hfunc = 0, p = name; (c = *p) != '\0'; p++)
    {
        hfunc = ((hfunc << 1) ^ (lowercase(c) & 0377)) % CHASHSIZE;
    }

    for (ps = &canontab[hfunc]; (s = *ps) != NULL; ps = &s->next)
    {
        if (sameword(s->name, name))
            break;
    }

/*
 * Allocate new entry if not found.
 * Only then is the actual check carried out.
 */
    if (s == NULL)
    {
        /* ps = &canontab[hfunc]; */
        s = newstruct(canon_tab_t);

        /* initialize new entry */
        s->name = newstr(name);
        s->status = canonical(name);

        /* link it in */
        s->next = *ps;
        *ps = s;
    }

    return(s->status);
}

/*
** CHECK_ADDR -- Check whether reverse address mappings revert to host
** -------------------------------------------------------------------
**
**    Returns:
**        TRUE if all addresses of host map back to host.
**        FALSE otherwise.
*/

bool
check_addr(name)
input char *name;            /* host name to check addresses for */
{
    struct hostent *hp;
    register int i;
    struct in_addr inaddr[MAXADDRS];
    int naddress;
    char hnamebuf[MAXDNAME+1];
    char *hname;
    char inamebuf[MAXDNAME+1];
    char *iname;
    int matched;

/*
 * Look up the specified host to fetch its addresses.
 */
    hp = gethostbyname(name);
    if (hp == NULL)
    {
        ns_error(name, T_A, C_IN, server);
        return(FALSE);
    }

    hname = strncpy(hnamebuf, hp->h_name, MAXDNAME);
    hname[MAXDNAME] = '\0';

    for (i = 0; i < MAXADDRS && hp->h_addr_list[i]; i++)
        inaddr[i] = incopy(hp->h_addr_list[i]);
    naddress = i;

    if (verbose)
        printf("Found %d address%s for %s\n",
            naddress, plurale(naddress), hname);

/*
 * Map back the addresses found, and check whether they revert to host.
 */
    for (matched = 0, i = 0; i < naddress; i++)
    {
        iname = strcpy(inamebuf, inet_ntoa(inaddr[i]));

        if (verbose)
            printf("Checking %s address %s\n", hname, iname);

        hp = gethostbyaddr((char *)&inaddr[i], INADDRSZ, AF_INET);
        if (hp == NULL)
            ns_error(iname, T_PTR, C_IN, server);
        else if (!sameword(hp->h_name, hname))
            pr_warning("%s address %s maps to %s",
                hname, iname, hp->h_name);
        else
            matched++;
    }

    return((matched == naddress) ? TRUE : FALSE);
}

/*
** CHECK_NAME -- Check whether address belongs to host addresses
** -------------------------------------------------------------
**
**    Returns:
**        TRUE if given address was found among host addresses.
**        FALSE otherwise.
*/

bool
check_name(addr)
input ipaddr_t addr;            /* address of host to check */
{
    struct hostent *hp;
    register int i;
    struct in_addr inaddr;
    char hnamebuf[MAXDNAME+1];
    char *hname;
    char inamebuf[MAXDNAME+1];
    char *iname;
    int matched;

/*
 * Check whether the address is registered by fetching its host name.
 */
    inaddr.s_addr = addr;
    iname = strcpy(inamebuf, inet_ntoa(inaddr));

    hp = gethostbyaddr((char *)&inaddr, INADDRSZ, AF_INET);
    if (hp == NULL)
    {
        ns_error(iname, T_PTR, C_IN, server);
        return(FALSE);
    }

    hname = strncpy(hnamebuf, hp->h_name, MAXDNAME);
    hname[MAXDNAME] = '\0';

    if (verbose)
        printf("Address %s maps to %s\n", iname, hname);

/*
 * Lookup the host name found to fetch its addresses.
 */
    hp = gethostbyname(hname);
    if (hp == NULL)
    {
        ns_error(hname, T_A, C_IN, server);
        return(FALSE);
    }

/*
 * Verify whether the mapped host name is canonical.
 */
    if (!sameword(hp->h_name, hname))
        pr_warning("%s host %s is not canonical (%s)",
            iname, hname, hp->h_name);

/*
 * Check whether the given address is listed among the known addresses.
 */
    for (matched = 0, i = 0; hp->h_addr_list[i]; i++)
    {
        inaddr = incopy(hp->h_addr_list[i]);

        if (verbose)
            printf("Checking %s address %s\n",
                hname, inet_ntoa(inaddr));

        if (inaddr.s_addr == addr)
            matched++;
    }

    if (!matched)
        pr_error("address %s does not belong to %s",
            iname, hname);

    return(matched ? TRUE : FALSE);
}

/*
** GETH_BYNAME -- Wrapper for gethostbyname
** ----------------------------------------
**
**    Returns:
**        Pointer to struct hostent if lookup was successful.
**        NULL otherwise.
**
**    Note. This routine works for fully qualified names only.
**    The entire special res_search() processing can be skipped.
*/

struct hostent *
geth_byname(name)
input CONST char *name;            /* name to do forward lookup for */
{
    querybuf answer;
    struct hostent *hp;
    register int n;

    hp = gethostbyname(name);
    if (hp != NULL)
        return(hp);

    if (verbose > print_level)
        printf("Finding addresses for %s ...\n", name);

    n = get_info(&answer, name, T_A, C_IN);
    if (n < 0)
        return(NULL);

    if ((verbose > print_level + 1) && (print_level < 1))
        (void) print_info(&answer, n, name, T_A, C_IN, FALSE);

    hp = gethostbyname(name);
    return(hp);
}

/*
** GETH_BYADDR -- Wrapper for gethostbyaddr
** ----------------------------------------
**
**    Returns:
**        Pointer to struct hostent if lookup was successful.
**        NULL otherwise.
*/

struct hostent *
geth_byaddr(addr, size, family)
input CONST char *addr;            /* address to do reverse mapping for */
input int size;                /* size of the address */
input int family;            /* address family */
{
    char addrbuf[4*4 + sizeof(ARPA_ROOT) + 1];
    char *name = addrbuf;
    u_char *a = (u_char *)addr;
    querybuf answer;
    struct hostent *hp;
    register int n;

    if (size != INADDRSZ || family != AF_INET)
    {
        hp = gethostbyaddr(addr, size, family);
        return(hp);
    }

    hp = gethostbyaddr(addr, size, family);
    if (hp != NULL)
        return(hp);

    /* construct absolute reverse name *without* trailing dot */
    (void) sprintf(addrbuf, "%u.%u.%u.%u.%s",
        a[3]&0xff, a[2]&0xff, a[1]&0xff, a[0]&0xff, ARPA_ROOT);

    if (verbose > print_level)
        printf("Finding reverse mapping for %s ...\n",
            inet_ntoa(incopy(addr)));

    n = get_info(&answer, name, T_PTR, C_IN);
    if (n < 0)
        return(NULL);

    if ((verbose > print_level + 1) && (print_level < 1))
        (void) print_info(&answer, n, name, T_PTR, C_IN, FALSE);

    hp = gethostbyaddr(addr, size, family);
    return(hp);
}

/*
** PARSE_TYPE -- Decode rr type from input string
** ----------------------------------------------
**
**    Returns:
**        Value of resource record type.
**        -1 if specified record name is invalid.
**
**    Note.    Several types are deprecated or obsolete, but recognized.
**        T_AXFR/T_IXFR is not allowed to be specified as query type.
*/

int
parse_type(str)
input char *str;            /* input string with record type */
{
    register int type;

        /* standard types */

    if (sameword(str, "A"))        return(T_A);
    if (sameword(str, "NS"))    return(T_NS);
    if (sameword(str, "MD"))    return(T_MD);        /* obsolete */
    if (sameword(str, "MF"))    return(T_MF);        /* obsolete */
    if (sameword(str, "CNAME"))    return(T_CNAME);
    if (sameword(str, "SOA"))    return(T_SOA);
    if (sameword(str, "MB"))    return(T_MB);        /* deprecated */
    if (sameword(str, "MG"))    return(T_MG);        /* deprecated */
    if (sameword(str, "MR"))    return(T_MR);        /* deprecated */
    if (sameword(str, "NULL"))    return(T_NULL);        /* obsolete */
    if (sameword(str, "WKS"))    return(T_WKS);
    if (sameword(str, "PTR"))    return(T_PTR);
    if (sameword(str, "HINFO"))    return(T_HINFO);
    if (sameword(str, "MINFO"))    return(T_MINFO);    /* deprecated */
    if (sameword(str, "MX"))    return(T_MX);
    if (sameword(str, "TXT"))    return(T_TXT);

        /* new types */

    if (sameword(str, "RP"))    return(T_RP);
    if (sameword(str, "AFSDB"))    return(T_AFSDB);
    if (sameword(str, "X25"))    return(T_X25);
    if (sameword(str, "ISDN"))    return(T_ISDN);
    if (sameword(str, "RT"))    return(T_RT);
    if (sameword(str, "NSAP"))    return(T_NSAP);
    if (sameword(str, "NSAP-PTR"))    return(T_NSAPPTR);
    if (sameword(str, "SIG"))    return(T_SIG);
    if (sameword(str, "KEY"))    return(T_KEY);
    if (sameword(str, "PX"))    return(T_PX);
    if (sameword(str, "GPOS"))    return(T_GPOS);        /* withdrawn */
    if (sameword(str, "AAAA"))    return(T_AAAA);
    if (sameword(str, "LOC"))    return(T_LOC);
    if (sameword(str, "NXT"))    return(T_NXT);
    if (sameword(str, "EID"))    return(T_EID);
    if (sameword(str, "NIMLOC"))    return(T_NIMLOC);
    if (sameword(str, "SRV"))    return(T_SRV);
    if (sameword(str, "ATMA"))    return(T_ATMA);
    if (sameword(str, "NAPTR"))    return(T_NAPTR);

        /* nonstandard types */

    if (sameword(str, "UINFO"))    return(T_UINFO);
    if (sameword(str, "UID"))    return(T_UID);
    if (sameword(str, "GID"))    return(T_GID);
    if (sameword(str, "UNSPEC"))    return(T_UNSPEC);

        /* filters */

    if (sameword(str, "IXFR"))    return(-1);        /* illegal */
    if (sameword(str, "AXFR"))    return(-1);        /* illegal */
    if (sameword(str, "MAILB"))    return(T_MAILB);
    if (sameword(str, "MAILA"))    return(T_MAILA);    /* obsolete */
    if (sameword(str, "ANY"))    return(T_ANY);
    if (sameword(str, "*"))        return(T_ANY);

        /* unknown types */

    type = atoi(str);
    if (type >= T_FIRST && type <= T_LAST)
        return(type);

    return(-1);
}

/*
** PARSE_CLASS -- Decode rr class from input string
** ------------------------------------------------
**
**    Returns:
**        Value of resource class.
**        -1 if specified class name is invalid.
**
**    Note.    C_CSNET is obsolete, but recognized.
*/

int
parse_class(str)
input char *str;            /* input string with resource class */
{
    register int class;

    if (sameword(str, "IN"))    return(C_IN);
    if (sameword(str, "INTERNET"))    return(C_IN);
    if (sameword(str, "CS"))    return(C_CSNET);    /* obsolete */
    if (sameword(str, "CSNET"))    return(C_CSNET);    /* obsolete */
    if (sameword(str, "CH"))    return(C_CHAOS);
    if (sameword(str, "CHAOS"))    return(C_CHAOS);
    if (sameword(str, "HS"))    return(C_HS);
    if (sameword(str, "HESIOD"))    return(C_HS);

    if (sameword(str, "ANY"))    return(C_ANY);
    if (sameword(str, "*"))        return(C_ANY);

    class = atoi(str);
    if (class > 0)
        return(class);

    return(-1);
}

/*
** IN_ADDR_ARPA -- Convert dotted quad string to reverse in-addr.arpa
** ------------------------------------------------------------------
**
**    Returns:
**        Pointer to appropriate reverse in-addr.arpa name
**        with trailing dot to force absolute domain name.
**        NULL in case of invalid dotted quad input string.
*/

char *
in_addr_arpa(dottedquad)
input char *dottedquad;            /* input string with dotted quad */
{
    static char addrbuf[4*4 + sizeof(ARPA_ROOT) + 2];
    unsigned int a[4];
    register int n;

    n = sscanf(dottedquad, "%u.%u.%u.%u", &a[0], &a[1], &a[2], &a[3]);
    switch (n)
    {
        case 4:
        (void) sprintf(addrbuf, "%u.%u.%u.%u.%s.",
            a[3]&0xff, a[2]&0xff, a[1]&0xff, a[0]&0xff, ARPA_ROOT);
        break;

        case 3:
        (void) sprintf(addrbuf, "%u.%u.%u.%s.",
            a[2]&0xff, a[1]&0xff, a[0]&0xff, ARPA_ROOT);
        break;

        case 2:
        (void) sprintf(addrbuf, "%u.%u.%s.",
            a[1]&0xff, a[0]&0xff, ARPA_ROOT);
        break;

        case 1:
        (void) sprintf(addrbuf, "%u.%s.",
            a[0]&0xff, ARPA_ROOT);
        break;

        default:
        return(NULL);
    }

    while (--n >= 0)
        if (a[n] > 255)
            return(NULL);

    return(addrbuf);
}

/*
** NSAP_INT -- Convert dotted nsap address string to reverse nsap.int
** ------------------------------------------------------------------
**
**    Returns:
**        Pointer to appropriate reverse nsap.int name
**        with trailing dot to force absolute domain name.
**        NULL in case of invalid nsap address input string.
*/

char *
nsap_int(name)
input char *name;            /* input string with dotted nsap */
{
    static char addrbuf[4*MAXNSAP + sizeof(NSAP_ROOT) + 2];
    register int n;
    register int i;

    /* skip optional leading hex indicator */
    if (samehead(name, "0x"))
        name += 2;

    for (n = 0, i = strlength(name)-1; i >= 0; --i)
    {
        /* skip optional interspersed separators */
        if (name[i] == '.' || name[i] == '+' || name[i] == '/')
            continue;

        /* must consist of hex digits only */
        if (!is_xdigit(name[i]))
            return(NULL);

        /* but not too many */
        if (n >= 4*MAXNSAP)
            return(NULL);

        addrbuf[n++] = name[i];
        addrbuf[n++] = '.';
    }

    /* must have an even number of hex digits */
    if (n == 0 || (n % 4) != 0)
        return(NULL);

    (void) sprintf(&addrbuf[n], "%s.", NSAP_ROOT);
    return(addrbuf);
}

/*
** PRINT_HOST -- Print host name and address of hostent struct
** -----------------------------------------------------------
**
**    Returns:
**        None.
*/

void
print_host(heading, hp)
input char *heading;            /* header string */
input struct hostent *hp;        /* location of hostent struct */
{
    register char **ap;

    printf("%s: %s", heading, hp->h_name);

    for (ap = hp->h_addr_list; ap && *ap; ap++)
    {
        if (ap == hp->h_addr_list)
            printf("\nAddress:");

        printf(" %s", inet_ntoa(incopy(*ap)));
    }

    for (ap = hp->h_aliases; ap && *ap && **ap; ap++)
    {
        if (ap == hp->h_aliases)
            printf("\nAliases:");

        printf(" %s", *ap);
    }

    printf("\n\n");
}

/*
** SHOW_RES -- Show resolver database information
** ----------------------------------------------
**
**    Returns:
**        None.
**
**    Inputs:
**        The resolver database _res is localized in the resolver.
*/

void
show_res()
{
    register int i;
    register char **domain;

/*
 * The default domain is defined by the "domain" entry in /etc/resolv.conf
 * if not overridden by the environment variable "LOCALDOMAIN".
 * If still not defined, gethostname() may yield a fully qualified host name.
 */
    printf("Default domain:");
    if (_res.defdname[0] != '\0')
        printf(" %s", _res.defdname);
    printf("\n");

/*
 * The search domains are extracted from the default domain components,
 * but may be overridden by "search" directives in /etc/resolv.conf
 * since 4.8.3.
 */
    printf("Search domains:");
    for (domain = _res.dnsrch; *domain; domain++)
        printf(" %s", *domain);
    printf("\n");

/*
 * The routine res_send() will do _res.retry tries to contact each of the
 * _res.nscount nameserver addresses before giving up when using datagrams.
 * The first try will timeout after _res.retrans seconds. Each following
 * try will timeout after ((_res.retrans << try) / _res.nscount) seconds.
 * Note. When we contact an explicit server the addresses will be replaced
 * by the multiple addresses of the same server.
 * When doing a zone transfer _res.retrans is used for the connect timeout.
 */
    printf("Timeout per retry: %d secs\n", _res.retrans);
    printf("Number of retries: %d\n", _res.retry);

    printf("Number of addresses: %d\n", _res.nscount);
    for (i = 0; i < _res.nscount; i++)
        printf("%s\n", inet_ntoa(nslist(i).sin_addr));

/*
 * The resolver options are initialized by res_init() to contain the
 * defaults settings (RES_RECURSE | RES_DEFNAMES | RES_DNSRCH)
 * The various options have the following meaning:
 *
 *    RES_INIT    set after res_init() has been called
 *    RES_DEBUG    let the resolver modules print debugging info
 *    RES_AAONLY    want authoritative answers only (not implemented)
 *    RES_USEVC    use tcp virtual circuit instead of udp datagrams
 *    RES_PRIMARY    use primary nameserver only (not implemented)
 *    RES_IGNTC    ignore datagram truncation; don't switch to tcp
 *    RES_RECURSE    forward query if answer not locally available
 *    RES_DEFNAMES    add default domain to queryname without dot
 *    RES_STAYOPEN    keep tcp socket open for subsequent queries
 *    RES_DNSRCH    append search domains even to queryname with dot
 */
    printf("Options set:");
    if (bitset(RES_INIT,      _res.options)) printf(" INIT");
    if (bitset(RES_DEBUG,     _res.options)) printf(" DEBUG");
    if (bitset(RES_AAONLY,    _res.options)) printf(" AAONLY");
    if (bitset(RES_USEVC,     _res.options)) printf(" USEVC");
    if (bitset(RES_PRIMARY,   _res.options)) printf(" PRIMARY");
    if (bitset(RES_IGNTC,     _res.options)) printf(" IGNTC");
    if (bitset(RES_RECURSE,   _res.options)) printf(" RECURSE");
    if (bitset(RES_DEFNAMES,  _res.options)) printf(" DEFNAMES");
    if (bitset(RES_STAYOPEN,  _res.options)) printf(" STAYOPEN");
    if (bitset(RES_DNSRCH,    _res.options)) printf(" DNSRCH");
    printf("\n");

    printf("Options clr:");
    if (!bitset(RES_INIT,     _res.options)) printf(" INIT");
    if (!bitset(RES_DEBUG,    _res.options)) printf(" DEBUG");
    if (!bitset(RES_AAONLY,   _res.options)) printf(" AAONLY");
    if (!bitset(RES_USEVC,    _res.options)) printf(" USEVC");
    if (!bitset(RES_PRIMARY,  _res.options)) printf(" PRIMARY");
    if (!bitset(RES_IGNTC,    _res.options)) printf(" IGNTC");
    if (!bitset(RES_RECURSE,  _res.options)) printf(" RECURSE");
    if (!bitset(RES_DEFNAMES, _res.options)) printf(" DEFNAMES");
    if (!bitset(RES_STAYOPEN, _res.options)) printf(" STAYOPEN");
    if (!bitset(RES_DNSRCH,   _res.options)) printf(" DNSRCH");
    printf("\n");

/*
 * The new BIND 4.9.3 has additional features which are not (yet) used.
 */
    printf("\n");
}

/*
** PRINT_STATISTICS -- Print resource record statistics
** ----------------------------------------------------
**
**    Returns:
**        None.
**
**    Inputs:
**        The record_stats[] counts have been updated by print_rrec().
*/

void
print_statistics(name, filter, class)
input char *name;            /* name of zone we are listing */
input int filter;            /* type of records we want to see */
input int class;            /* class of records we want to see */
{
    register int type;
    int nrecords;

    for (type = T_FIRST; type <= T_LAST; type++)
    {
        nrecords = record_stats[type];
        if (nrecords > 0 || ((filter != T_ANY) && want_type(type, filter)))
        {
            printf("Found %4d %-5s record%-1s", nrecords,
                pr_type(type), plural(nrecords));

            if (class != C_IN)
                printf(" in class %s", pr_class(class));

            printf(" within %s\n", name);
        }
    }
}


/*
** CLEAR_STATISTICS -- Clear resource record statistics
** ----------------------------------------------------
**
**    Returns:
**        None.
*/

void
clear_statistics()
{
    bzero((char *)record_stats, sizeof(record_stats));
}

/*
** SHOW_TYPES -- Show resource record types wanted
** -----------------------------------------------
**
**    Returns:
**        None.
*/

void
show_types(name, filter, class)
input char *name;            /* name we want to query about */
input int filter;            /* type of records we want to see */
input int class;            /* class of records we want to see */
{
    register int type;

    if (filter >= T_NONE)
    {
        printf("Query about %s for record types", name);

        if (filter == T_ANY)
            printf(" %s", pr_type(T_ANY));
        else
            for (type = T_FIRST; type <= T_LAST; type++)
                if (want_type(type, filter))
                    printf(" %s", pr_type(type));

        if (class != C_IN)
            printf(" in class %s", pr_class(class));

        printf("\n");
    }
}

/*
** NS_ERROR -- Print error message from errno and h_errno
** ------------------------------------------------------
**
**    Returns:
**        None.
**
** If BIND res_send() fails, it will leave errno in either of the first
** two following states when using datagrams. Note that this depends on
** the proper handling of connected datagram sockets, which is usually
** true if BSD >= 43 (see res_send.c for details; it may need a patch).
** Note. If the 4.8 version succeeds, it may leave errno as EAFNOSUPPORT
** if it has disconnected a previously connected datagram socket, since
** the dummy address used to disconnect does not have a proper family set.
** Always clear errno after getting a reply, or patch res_send().
** Our private version of res_send() will leave also other error statuses.
*/

void
ns_error(name, type, class, host)
input char *name;            /* full name we queried about */
input int type;                /* record type we queried about */
input int class;            /* record class we queried about */
input char *host;            /* set if explicit server was used */
{
    static char *auth = "Authoritative answer";

/*
 * Print the message associated with the network related errno values.
 */
    switch (errno)
    {
        case ECONNREFUSED:
        /*
         * The contacted host does not have a nameserver running.
         * The standard res_send() also returns this if none of
         * the intended hosts could be reached via datagrams.
         */
        if (host != NULL)
            errmsg("Nameserver %s not running", host);
        else
            errmsg("Nameserver not running");
        break;

        case ETIMEDOUT:
        /*
         * The contacted server did not give any reply at all
         * within the specified time frame.
         */
        if (host != NULL)
            errmsg("Nameserver %s not responding", host);
        else
            errmsg("Nameserver not responding");
        break;

        case ENETDOWN:
        case ENETUNREACH:
        case EHOSTDOWN:
        case EHOSTUNREACH:
        /*
         * The host to be contacted or its network can not be reached.
         * Our private res_send() also returns this using datagrams.
         */
        if (host != NULL)
            errmsg("Nameserver %s not reachable", host);
        else
            errmsg("Nameserver not reachable");
        break;
    }

/*
 * Print the message associated with the particular nameserver error.
 */
    switch (h_errno)
    {
        case HOST_NOT_FOUND:
        /*
         * The specified name does definitely not exist at all.
         * In this case the answer is always authoritative.
         * Nameserver status: NXDOMAIN
         */
        if (class != C_IN)
            errmsg("%s does not exist in class %s (%s)",
                name, pr_class(class), auth);
        else if (host != NULL)
            errmsg("%s does not exist at %s (%s)",
                name, host, auth);
        else
            errmsg("%s does not exist (%s)",
                name, auth);
        break;

        case NO_HOST:
        /*
         * The specified name does not exist, but the answer
         * was not authoritative, so it is still undecided.
         * Nameserver status: NXDOMAIN
         */
        if (class != C_IN)
            errmsg("%s does not exist in class %s, try again",
                name, pr_class(class));
        else if (host != NULL)
            errmsg("%s does not exist at %s, try again",
                name, host);
        else
            errmsg("%s does not exist, try again",
                name);
        break;

        case NO_DATA:
        /*
         * The name is valid, but the specified type does not exist.
         * This status is here returned only in case authoritative.
         * Nameserver status: NOERROR
         */
        if (class != C_IN)
            errmsg("%s has no %s record in class %s (%s)",
                name, pr_type(type), pr_class(class), auth);
        else if (host != NULL)
            errmsg("%s has no %s record at %s (%s)",
                name, pr_type(type), host, auth);
        else
            errmsg("%s has no %s record (%s)",
                name, pr_type(type), auth);
        break;

        case NO_RREC:
        /*
         * The specified type does not exist, but we don't know whether
         * the name is valid or not. The answer was not authoritative.
         * Perhaps recursion was off, and no data was cached locally.
         * Nameserver status: NOERROR
         */
        if (class != C_IN)
            errmsg("%s %s record in class %s currently not present",
                name, pr_type(type), pr_class(class));
        else if (host != NULL)
            errmsg("%s %s record currently not present at %s",
                name, pr_type(type), host);
        else
            errmsg("%s %s record currently not present",
                name, pr_type(type));
        break;

        case TRY_AGAIN:
        /*
         * Some intermediate failure, e.g. connect timeout,
         * or some local operating system transient errors.
         * General failure to reach any appropriate servers.
         * The status SERVFAIL now yields a separate error code.
         * Nameserver status: (SERVFAIL)
         */
        if (class != C_IN)
            errmsg("%s %s record in class %s not found, try again",
                name, pr_type(type), pr_class(class));
        else if (host != NULL)
            errmsg("%s %s record not found at %s, try again",
                name, pr_type(type), host);
        else
            errmsg("%s %s record not found, try again",
                name, pr_type(type));
        break;

        case SERVER_FAILURE:
        /*
         * Explicit server failure status. This will be returned upon
         * some internal server errors, forwarding failures, or when
         * the server is not authoritative for a specific class.
         * Also if the zone data has expired at a secondary server.
         * Nameserver status: SERVFAIL
         */
        if (class != C_IN)
            errmsg("%s %s record in class %s not found, server failure",
                name, pr_type(type), pr_class(class));
        else if (host != NULL)
            errmsg("%s %s record not found at %s, server failure",
                name, pr_type(type), host);
        else
            errmsg("%s %s record not found, server failure",
                name, pr_type(type));
        break;

        case NO_RECOVERY:
        /*
         * Some irrecoverable format error, or server refusal.
         * The status REFUSED now yields a separate error code.
         * Nameserver status: (REFUSED) FORMERR NOTIMP NOCHANGE
         */
        if (class != C_IN)
            errmsg("%s %s record in class %s not found, no recovery",
                name, pr_type(type), pr_class(class));
        else if (host != NULL)
            errmsg("%s %s record not found at %s, no recovery",
                name, pr_type(type), host);
        else
            errmsg("%s %s record not found, no recovery",
                name, pr_type(type));
        break;

        case QUERY_REFUSED:
        /*
         * The server explicitly refused to answer the query.
         * Servers can be configured to disallow zone transfers.
         * Nameserver status: REFUSED
         */
        if (class != C_IN)
            errmsg("%s %s record in class %s query refused",
                name, pr_type(type), pr_class(class));
        else if (host != NULL)
            errmsg("%s %s record query refused by %s",
                name, pr_type(type), host);
        else
            errmsg("%s %s record query refused",
                name, pr_type(type));
        break;

        default:
        /*
         * Unknown cause for server failure.
         */
        if (class != C_IN)
            errmsg("%s %s record in class %s not found",
                name, pr_type(type), pr_class(class));
        else if (host != NULL)
            errmsg("%s %s record not found at %s",
                name, pr_type(type), host);
        else
            errmsg("%s %s record not found",
                name, pr_type(type));
        break;
    }
}

/*
** DECODE_ERROR -- Convert nameserver error code to error message
** --------------------------------------------------------------
**
**    Returns:
**        Pointer to appropriate error message.
*/

char *
decode_error(rcode)
input int rcode;            /* error code from bp->rcode */
{
    switch (rcode)
    {
        case NOERROR:     return("no error");
        case FORMERR:    return("format error");
        case SERVFAIL:    return("server failure");
        case NXDOMAIN:    return("non-existent domain");
        case NOTIMP:    return("not implemented");
        case REFUSED:    return("query refused");
        case NOCHANGE:    return("no change");
    }

    return("unknown error");
}

/*
** PRINT_STATUS -- Print result status after nameserver query
** ----------------------------------------------------------
**
**    Returns:
**        None.
**
**    Conditions:
**        The size of the answer buffer must have been
**        checked before to be of sufficient length,
**        i.e. to contain at least the buffer header.
*/

void
print_status(answerbuf, answerlen)
input querybuf *answerbuf;        /* location of answer buffer */
input int answerlen;            /* length of answer buffer */
{
    HEADER *bp;
    int ancount;
    bool failed;

    bp = (HEADER *)answerbuf;
    ancount = ntohs(bp->ancount);
    failed = (bp->rcode != NOERROR || ancount == 0);

    printf("%s", verbose ? "" : dbprefix);

    printf("Query %s", failed ? "failed" : "done");

    if (bp->tc || (answerlen > PACKETSZ))
        printf(", %d byte%s", answerlen, plural(answerlen));

    if (bp->tc)
    {
        if (answerlen > sizeof(querybuf))
            printf(" (truncated to %d)", sizeof(querybuf));
        else
            printf(" (truncated)");
    }

    printf(", %d answer%s", ancount, plural(ancount));

    printf(", %s", bp->aa ? "authoritative " : "");

    printf("status: %s\n", decode_error((int)bp->rcode));
}

/*
** PR_ERROR -- Print error message about encountered inconsistencies
** -----------------------------------------------------------------
**
**    We are supposed to have an error condition which is fatal
**    for normal continuation, and the message is always printed.
**
**    Returns:
**        None.
**
**    Side effects:
**        Increments the global error count.
*/

void /*VARARGS1*/
pr_error(fmt, a, b, c, d)
input char *fmt;            /* format of message */
input char *a, *b, *c, *d;        /* optional arguments */
{
    (void) fprintf(stderr, " *** ");
    (void) fprintf(stderr, fmt, a, b, c, d);
    (void) fprintf(stderr, "\n");

    /* flag an error */
    errorcount++;
}


/*
** PR_WARNING -- Print warning message about encountered inconsistencies
** ---------------------------------------------------------------------
**
**    We are supposed to have an error condition which is non-fatal
**    for normal continuation, and the message is suppressed in case
**    quiet mode has been selected.
**
**    Returns:
**        None.
*/

void /*VARARGS1*/
pr_warning(fmt, a, b, c, d)
input char *fmt;            /* format of message */
input char *a, *b, *c, *d;        /* optional arguments */
{
    if (!quiet)
    {
        (void) fprintf(stderr, " !!! ");
        (void) fprintf(stderr, fmt, a, b, c, d);
        (void) fprintf(stderr, "\n");
    }
}

/*
** WANT_TYPE -- Indicate whether the rr type matches the desired filter
** --------------------------------------------------------------------
**
**    Returns:
**        TRUE if the resource record type matches the filter.
**        FALSE otherwise.
**
**    In regular mode, the querytype is used to formulate the query,
**    and the filter is set to T_ANY to filter out any response.
**    In listmode, we get everything, so the filter is set to the
**    querytype to filter out the proper responses.
**    Note that T_NONE is the default querytype in listmode.
*/

bool
want_type(type, filter)
input int type;                /* resource record type */
input int filter;            /* type of records we want to see */
{
    if (type == filter)
        return(TRUE);

    if (filter == T_ANY)
        return(TRUE);

    if (filter == T_NONE &&
       (type == T_A || type == T_NS || type == T_PTR))
        return(TRUE);

    if (filter == T_MAILB &&
       (type == T_MB || type == T_MR || type == T_MG || type == T_MINFO))
        return(TRUE);

    if (filter == T_MAILA &&
       (type == T_MD || type == T_MF))
        return(TRUE);

    return(FALSE);
}

/*
** WANT_CLASS -- Indicate whether the rr class matches the desired filter
** ----------------------------------------------------------------------
**
**    Returns:
**        TRUE if the resource record class matches the filter.
**        FALSE otherwise.
**
**    In regular mode, the queryclass is used to formulate the query,
**    and the filter is set to C_ANY to filter out any response.
**    In listmode, we get everything, so the filter is set to the
**    queryclass to filter out the proper responses.
**    Note that C_IN is the default queryclass in listmode.
*/

bool
want_class(class, filter)
input int class;            /* resource record class */
input int filter;            /* class of records we want to see */
{
    if (class == filter)
        return(TRUE);

    if (filter == C_ANY)
        return(TRUE);

    return(FALSE);
}

/*
** INDOMAIN -- Check whether a name belongs to a zone
** --------------------------------------------------
**
**    Returns:
**        TRUE if the given name lies anywhere in the zone, or
**        if the given name is the same as the zone and may be so.
**        FALSE otherwise.
*/

bool
indomain(name, domain, equal)
input char *name;            /* the name under consideration */
input char *domain;            /* the name of the zone */
input bool equal;            /* set if name may be same as zone */
{
    register char *dot;

    if (sameword(name, domain))
        return(equal);

    if (sameword(domain, "."))
        return(TRUE);

    dot = index(name, '.');
    while (dot != NULL)
    {
        if (!is_quoted(dot, name))
        {
            if (sameword(dot+1, domain))
                return(TRUE);
        }

        dot = index(dot+1, '.');
    }

    return(FALSE);
}

/*
** SAMEDOMAIN -- Check whether a name belongs to a zone
** ----------------------------------------------------
**
**    Returns:
**        TRUE if the given name lies directly in the zone, or
**        if the given name is the same as the zone and may be so.
**        FALSE otherwise.
*/

bool
samedomain(name, domain, equal)
input char *name;            /* the name under consideration */
input char *domain;            /* the name of the zone */
input bool equal;            /* set if name may be same as zone */
{
    register char *dot;

    if (sameword(name, domain))
        return(equal);

    dot = index(name, '.');
    while (dot != NULL)
    {
        if (!is_quoted(dot, name))
        {
            if (sameword(dot+1, domain))
                return(TRUE);

            return(FALSE);
        }

        dot = index(dot+1, '.');
    }

    if (sameword(domain, "."))
        return(TRUE);

    return(FALSE);
}

/*
** GLUERECORD -- Check whether a name is a glue record
** ---------------------------------------------------
**
**    Returns:
**        TRUE is this is a glue record.
**        FALSE otherwise.
**
**    The name is supposed to be the name of an address record.
**    If it lies directly in the given zone, it is considered
**    an ordinary host within that zone, and not a glue record.
**    If it does not belong to the given zone at all, is it
**    here considered to be a glue record.
**    If it lies in the given zone, but not directly, it is
**    considered a glue record if it belongs to any of the known
**    delegated zones of the given zone.
**    In the root zone itself are no hosts, only glue records.
*/

bool
gluerecord(name, domain, zone, nzones)
input char *name;            /* the name under consideration */
input char *domain;            /* name of zone being processed */
input char *zone[];            /* list of known delegated zones */
input int nzones;            /* number of known delegated zones */
{
    register int n;

    if (sameword(domain, "."))
        return(TRUE);

    if (samedomain(name, domain, TRUE))
        return(FALSE);

    if (!indomain(name, domain, TRUE))
        return(TRUE);

    for (n = 0; n < nzones; n++)
        if (indomain(name, zone[n], TRUE))
            return(TRUE);

    return(FALSE);
}

/*
** MATCHLABELS -- Determine number of matching domain name labels
** --------------------------------------------------------------
**
**    Returns:
**        Number of shared trailing components in both names.
**
**    Note. This routine is currently used only to compare nameserver
**    names in the RHS of NS records, so there is no need to check
**    for embedded quoted dots.
*/

int
matchlabels(name, domain)
input char *name;            /* domain name to check */
input char *domain;            /* domain name to compare against */
{
    register int i, j;
    int matched = 0;

    i = strlength(name);
    j = strlength(domain);

    while (--i >= 0 && --j >= 0)
    {
        if (lowercase(name[i]) != lowercase(domain[j]))
            break;
        if (domain[j] == '.')
            matched++;
        else if (j == 0 && (i == 0 || name[i-1] == '.'))
            matched++;
    }

    return(matched);
}

/*
** PR_DOMAIN -- Convert domain name according to printing options
** --------------------------------------------------------------
**
**    Returns:
**        Pointer to new domain name, if conversion was done.
**        Pointer to original name, if no conversion necessary.
*/

char *
pr_domain(name, listing)
input char *name;            /* domain name to be printed */
input bool listing;            /* set if this is a zone listing */
{
    char *newname;            /* converted domain name */

/*
 * Print reverse nsap.int name in forward notation, unless prohibited.
 */
    if (revnsap && !dotprint)
    {
        newname = pr_nsap(name);
        if (newname != name)
            return(newname);
    }

/*
 * Print domain names with trailing dot if necessary.
 */
    if (listing || dotprint)
    {
        newname = pr_dotname(name);
        if (newname != name)
            return(newname);
    }

/*
 * No conversion was required, use original name.
 */
    return(name);
}

/*
** PR_DOTNAME -- Return domain name with trailing dot
** --------------------------------------------------
**
**    Returns:
**        Pointer to new domain name, if dot was added.
**        Pointer to original name, if dot was already present.
*/

char *
pr_dotname(name)
input char *name;            /* domain name to append to */
{
    static char buf[MAXDNAME+2];    /* buffer to store new domain name */
    register int n;

    n = strlength(name);
    if (n > 0 && name[n-1] == '.')
        return(name);

    if (n > MAXDNAME)
        n = MAXDNAME;

#ifdef obsolete
    (void) sprintf(buf, "%.*s.", MAXDNAME, name);
#endif
    bcopy(name, buf, n);
    buf[n] = '.';
    buf[n+1] = '\0';
    return(buf);
}

/*
** PR_NSAP -- Convert reverse nsap.int to dotted forward notation
** --------------------------------------------------------------
**
**    Returns:
**        Pointer to new dotted nsap, if converted.
**        Pointer to original name otherwise.
*/

char *
pr_nsap(name)
input char *name;            /* potential reverse nsap.int name */
{
    static char buf[3*MAXNSAP+1];
    register char *p;
    register int n;
    register int i;

    /* must begin with single hex digits separated by dots */
    for (i = 0; is_xdigit(name[i]) && name[i+1] == '.'; i += 2)
        continue;

    /* must have an even number of hex digits */
    if (i == 0 || (i % 4) != 0)
        return(name);

    /* but not too many */
    if (i > 4*MAXNSAP)
        return(name);

    /* must end in the appropriate root domain */
    if (!sameword(&name[i], NSAP_ROOT))
        return(name);

    for (p = buf, n = 0; i >= 4; i -= 4, n++)
    {
        *p++ = name[i-2];
        *p++ = name[i-4];

        /* add dots for readability */
        if ((n % 2) == 0 && (i - 4) > 0)
            *p++ = '.';
    }
    *p = '\0';

    return(buf);
}

/*
** PR_TYPE -- Return name of resource record type
** ----------------------------------------------
**
**    Returns:
**        Pointer to name of resource record type.
**
**    Note.    All possible (even obsolete) types are recognized.
*/

char *
pr_type(type)
input int type;                /* resource record type */
{
    static char buf[30];        /* sufficient for 64-bit values */

    switch (type)
    {
        /* standard types */

        case T_A:       return("A");    /* internet address */
        case T_NS:      return("NS");    /* authoritative server */
        case T_MD:      return("MD");    /* mail destination */
        case T_MF:      return("MF");    /* mail forwarder */
        case T_CNAME:   return("CNAME");    /* canonical name */
        case T_SOA:     return("SOA");    /* start of auth zone */
        case T_MB:      return("MB");    /* mailbox domain name */
        case T_MG:      return("MG");    /* mail group member */
        case T_MR:      return("MR");    /* mail rename name */
        case T_NULL:    return("NULL");    /* null resource record */
        case T_WKS:     return("WKS");    /* well known service */
        case T_PTR:     return("PTR");    /* domain name pointer */
        case T_HINFO:   return("HINFO");    /* host information */
        case T_MINFO:   return("MINFO");    /* mailbox information */
        case T_MX:      return("MX");    /* mail routing info */
        case T_TXT:     return("TXT");    /* descriptive text */

        /* new types */

        case T_RP:      return("RP");    /* responsible person */
        case T_AFSDB:   return("AFSDB");    /* afs database location */
        case T_X25:     return("X25");    /* x25 address */
        case T_ISDN:    return("ISDN");    /* isdn address */
        case T_RT:      return("RT");    /* route through host */
        case T_NSAP:    return("NSAP");    /* nsap address */
        case T_NSAPPTR: return("NSAP-PTR");    /* nsap pointer */
        case T_SIG:     return("SIG");    /* security signature */
        case T_KEY:     return("KEY");    /* security key */
        case T_PX:      return("PX");    /* rfc822 - x400 mapping */
        case T_GPOS:    return("GPOS");    /* geographical position */
        case T_AAAA:    return("AAAA");    /* ip v6 address */
        case T_LOC:     return("LOC");    /* geographical location */
        case T_NXT:     return("NXT");    /* next valid name */
        case T_EID:     return("EID");    /* endpoint identifier */
        case T_NIMLOC:  return("NIMLOC");    /* nimrod locator */
        case T_SRV:     return("SRV");    /* service info */
        case T_ATMA:    return("ATMA");    /* atm address */
        case T_NAPTR:   return("NAPTR");    /* naming authority urn */

        /* nonstandard types */

        case T_UINFO:   return("UINFO");    /* user information */
        case T_UID:     return("UID");    /* user ident */
        case T_GID:     return("GID");    /* group ident */
        case T_UNSPEC:  return("UNSPEC");    /* unspecified binary data */

        /* filters */

        case T_IXFR:    return("IXFR");    /* incremental zone transfer */
        case T_AXFR:    return("AXFR");    /* zone transfer */
        case T_MAILB:   return("MAILB");    /* matches MB/MR/MG/MINFO */
        case T_MAILA:   return("MAILA");    /* matches MD/MF */
        case T_ANY:     return("ANY");    /* matches any type */

        case T_NONE:    return("resource");    /* not yet determined */
    }

    /* unknown type */
    (void) sprintf(buf, "%d", type);
    return(buf);
}

/*
** PR_CLASS -- Return name of resource record class
** ------------------------------------------------
**
**    Returns:
**        Pointer to name of resource record class.
*/

char *
pr_class(class)
input int class;            /* resource record class */
{
    static char buf[30];        /* sufficient for 64-bit values */

    switch (class)
    {
        case C_IN:      return("IN");    /* internet */
        case C_CSNET:   return("CS");    /* csnet */
        case C_CHAOS:   return("CH");    /* chaosnet */
        case C_HS:      return("HS");    /* hesiod */
        case C_ANY:     return("ANY");    /* any class */
    }

    /* unknown class */
    (void) sprintf(buf, "%d", class);
    return(buf);
}

/*
** EXPAND_NAME -- Expand compressed domain name in a resource record
** -----------------------------------------------------------------
**
**    Returns:
**        Number of bytes advanced in answer buffer.
**        -1 if there was a format error.
**
**    It is assumed that the specified buffer is of a fixed size
**    MAXDNAME+1 that should be sufficient to store the data.
*/

int
expand_name(name, type, cp, msg, eom, namebuf)
input char *name;            /* name of resource record */
input int type;                /* type of resource record */
input u_char *cp;            /* current position in answer buf */
input u_char *msg, *eom;        /* begin and end of answer buf */
output char *namebuf;            /* location of buf to expand name in */
{
    register int n;

    n = dn_expand(msg, eom, cp, (nbuf_t *)namebuf, MAXDNAME);
    if (n < 0)
    {
        pr_error("expand error in %s record for %s, offset %s",
            pr_type(type), name, itoa(cp - msg));
        h_errno = NO_RECOVERY;
        return(-1);
    }

    /* should not be necessary, but who knows */
    namebuf[MAXDNAME] = '\0';

    /* change root to single dot */
    if (namebuf[0] == '\0')
    {
        namebuf[0] = '.';
        namebuf[1] = '\0';
    }

    return(n);
}

/*
** CHECK_SIZE -- Check whether resource record is of sufficient length
** -------------------------------------------------------------------
**
**    Returns:
**        Requested size if current record is long enough.
**        -1 if current record does not have this many bytes.
**
**    Note that HINFO records are very often incomplete since only
**    one of the two data fields has been filled in and the second
**    field is missing. So we generate only a warning message.
*/

int
check_size(name, type, cp, msg, eor, size)
input char *name;            /* name of resource record */
input int type;                /* type of resource record */
input u_char *cp;            /* current position in answer buf */
input u_char *msg;            /* begin of answer buf */
input u_char *eor;            /* predicted position of next record */
input int size;                /* required record size remaining */
{
    if (cp + size > eor)
    {
        if (type != T_HINFO)
            pr_error("incomplete %s record for %s, offset %s",
                pr_type(type), name, itoa(cp - msg));
        else
            pr_warning("incomplete %s record for %s",
                pr_type(type), name);
        h_errno = NO_RECOVERY;
        return(-1);
    }

    return(size);
}

/*
** VALID_NAME -- Check whether domain name contains invalid characters
** -------------------------------------------------------------------
**
**    Returns:
**        TRUE if the name is valid.
**        FALSE otherwise.
**
**    The total size of a compound name should not exceed MAXDNAME.
**    We assume that this is true. Its individual components between
**    dots should not be longer than 64. This is not checked here.
**
**    Only alphanumeric characters and dash '-' may be used (dash
**    only in the middle). We only check the individual characters.
**    Strictly speaking, this restriction is only for ``host names''.
**    The underscore is illegal, at least not recommended, but is
**    so abundant that it requires special processing.
**
**    If the domain name represents a mailbox specification, the
**    first label up to the first (unquoted) dot is the local part
**    of a mail address, which should adhere to the RFC 822 specs.
**    This first dot takes the place of the RFC 822 '@' sign.
**
**    The label '*' can in principle be used anywhere to indicate
**    wildcarding. It is valid only in the LHS resource record name,
**    in definitions in zone files only as the first component.
**    Used primarily in wildcard MX record definitions.
**
**    Note. This routine is much too liberal.
*/

char *specials = ".()<>@,;:\\\"[]";    /* RFC 822 specials */

bool
valid_name(name, wildcard, localpart, underscore)
input char *name;            /* domain name to check */
input bool wildcard;            /* set if wildcard is allowed */
input bool localpart;            /* set if this is a mailbox spec */
input bool underscore;            /* set if underscores are allowed */
{
    bool backslash = FALSE;
    bool quoting = FALSE;
    register char *p;
    register char c;

    for (p = name; (c = *p) != '\0'; p++)
    {
        /* special check for local part in mailbox */
        if (localpart)
        {
            if (backslash)
                backslash = FALSE;    /* escape this char */
            else if (c == '\\')
                backslash = TRUE;    /* escape next char */
            else if (c == '"')
                quoting = !quoting;    /* start/stop quoting */
            else if (quoting)
                continue;        /* allow quoted chars */
            else if (c == '.')
                localpart = FALSE;    /* instead of '@' */
            else if (c == '@')
                return(FALSE);        /* should be '.' */
            else if (in_string(specials, c))
                return(FALSE);        /* must be escaped */
            else if (is_space(c))
                return(FALSE);        /* must be escaped */
            continue;
        }

        /* basic character set */
        if (is_alnum(c) || (c == '-'))
            continue;

        /* start of a new component */
        if (c == '.')
            continue;

        /* allow '*' for use in wildcard names */
        if ((c == '*') && (p == name && p[1] == '.') && wildcard)
            continue;

        /* ignore underscore in certain circumstances */
        if ((c == '_') && underscore && !illegal)
            continue;

        /* silently allowed widespread exceptions */
        if (illegal && in_string(illegal, c))
            continue;

        return(FALSE);
    }

    /* must be beyond the local part in a mailbox */
    if (localpart)
        return(FALSE);

    return(TRUE);
}

/*
** CANONICAL -- Check whether domain name is a canonical host name
** ---------------------------------------------------------------
**
**    Returns:
**        Nonzero if the name is definitely not canonical.
**        0 if it is canonical, or if it remains undecided.
*/

int
canonical(name)
input char *name;            /* the domain name to check */
{
    struct hostent *hp;
    int status;
    int save_errno;
    int save_herrno;

/*
 * Preserve state when querying, to avoid clobbering current values.
 */
    save_errno = errno;
    save_herrno = h_errno;

    hp = geth_byname(name);
    status = h_errno;

    errno = save_errno;
    h_errno = save_herrno;

/*
 * Indicate negative result only after definitive lookup failures.
 */
    if (hp == NULL)
    {
        /* authoritative denial -- not existing or no A record */
        if (status == NO_DATA || status == HOST_NOT_FOUND)
            return(status);

        /* nameserver failure -- still undecided, assume ok */
        return(0);
    }

/*
 * The given name exists and there is an associated A record.
 * The name of this A record should be the name we queried about.
 * If this is not the case we probably supplied a CNAME.
 */
    status = sameword(hp->h_name, name) ? 0 : HOST_NOT_CANON;
    return(status);
}

/*
** MAPREVERSE -- Check whether address maps back to given domain
** -------------------------------------------------------------
**
**    Returns:
**        NULL if address could definitively not be mapped.
**        Given name if the address maps back properly, or
**        in case of transient nameserver failures.
**        Reverse name if it differs from the given name.
*/

char *
mapreverse(name, inaddr)
input char *name;            /* domain name of A record */
input struct in_addr inaddr;        /* address of A record to check */
{
    struct hostent *hp;
    int status;
    int save_errno;
    int save_herrno;

/*
 * Preserve state when querying, to avoid clobbering current values.
 */
    save_errno = errno;
    save_herrno = h_errno;

    hp = geth_byaddr((char *)&inaddr, INADDRSZ, AF_INET);
    status = h_errno;

    errno = save_errno;
    h_errno = save_herrno;

/*
 * Indicate negative result only after definitive lookup failures.
 */
    if (hp == NULL)
    {
        /* authoritative denial -- not existing or no PTR record */
        if (status == NO_DATA || status == HOST_NOT_FOUND)
            return(NULL);

        /* nameserver failure -- still undecided, assume ok */
        return(name);
    }

/*
 * Indicate whether the reverse mapping yields the given name.
 */
    return(sameword(hp->h_name, name) ? name : hp->h_name);
}

/*
** COMPARE_NAME -- Compare two names wrt alphabetical order
** --------------------------------------------------------
**
**    Returns:
**        Value of case-insensitive comparison.
*/

int
compare_name(a, b)
input const ptr_t *a;            /* first name */
input const ptr_t *b;            /* second name */
{
    return(strcasecmp(*(char **)a, *(char **)b));
}

/*
** XALLOC -- Allocate or reallocate additional memory
** --------------------------------------------------
**
**    Returns:
**        Pointer to (re)allocated buffer space.
**        Aborts if the requested memory could not be obtained.
*/

ptr_t *
xalloc(buf, size)
register ptr_t *buf;            /* current start of buffer space */
input siz_t size;            /* number of bytes to allocate */
{
    if (buf == NULL)
        buf = malloc(size);
    else
        buf = realloc(buf, size);

    if (buf == NULL)
    {
        errmsg("Out of memory");
        exit(EX_OSERR);
    }

    return(buf);
}

/*
** ITOA -- Convert value to decimal integer ascii string
** -----------------------------------------------------
**
**    Returns:
**        Pointer to string.
*/

char *
itoa(n)
input int n;                /* value to convert */
{
    static char buf[30];        /* sufficient for 64-bit values */

    (void) sprintf(buf, "%d", n);
    return(buf);
}

/*
** UTOA -- Convert value to unsigned decimal ascii string
** ------------------------------------------------------
**
**    Returns:
**        Pointer to string.
*/

char *
utoa(n)
input int n;                /* value to convert */
{
    static char buf[30];        /* sufficient for 64-bit values */

    (void) sprintf(buf, "%u", (unsigned)n);
    return(buf);
}

/*
** XTOA -- Convert value to hexadecimal ascii string
** -------------------------------------------------
**
**    Returns:
**        Pointer to string.
*/

char *
xtoa(n)
input int n;                /* value to convert */
{
    static char buf[17];        /* sufficient for 64-bit values */

    (void) sprintf(buf, "%X", (unsigned)n);
    return(buf);
}

/*
** STOA -- Extract partial ascii string, escape if necessary
** ---------------------------------------------------------
**
**    Returns:
**        Pointer to string.
*/

char *
stoa(cp, size, escape)
input u_char *cp;            /* current position in answer buf */
input int size;                /* number of bytes to extract */
input bool escape;            /* escape special characters if set */
{
    static char buf[2*MAXDLEN+1];
    register char *p;
    register char c;
    register int i;

    if (size > MAXDLEN)
        size = MAXDLEN;

#ifdef obsolete
    if (size > 0)
        (void) sprintf(buf, "%.*s", size, (char *)cp);
    else
        (void) sprintf(buf, "%s", "");
#endif

    for (p = buf, i = 0; i < size; i++)
    {
        c = *cp++;
        if (escape && (c == '\n' || c == '\\' || c == '"'))
            *p++ = '\\';
        *p++ = c;
    }
    *p = '\0';

    return(buf);
}

/*
** BASE_NTOA -- Convert binary data to base64 ascii
** ------------------------------------------------
**
**    Returns:
**        Pointer to string.
**
**    This routine is used to convert encoded keys and signatures
**    in T_KEY and T_SIG resource records.
*/

char b64tab[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

char *
base_ntoa(cp, size)
input u_char *cp;            /* current position in answer buf */
input int size;                /* number of bytes to extract */
{
    static char buf[MAXB64SIZE+1];
    register char *p;
    int c1, c2, c3, c4;

    if (size > MAXMD5SIZE)
        size = MAXMD5SIZE;

    for (p = buf; size > 2; cp += 3, size -= 3)
    {
        c1 = (((int)cp[0] >> 2) & 0x3f);
        c2 = (((int)cp[0] & 0x03) << 4) + (((int)cp[1] >> 4) & 0x0f);
        c3 = (((int)cp[1] & 0x0f) << 2) + (((int)cp[2] >> 6) & 0x03);
        c4 =  ((int)cp[2] & 0x3f);

        *p++ = b64tab[c1];
        *p++ = b64tab[c2];
        *p++ = b64tab[c3];
        *p++ = b64tab[c4];
    }

    if (size == 2)
    {
        c1 = (((int)cp[0] >> 2) & 0x3f);
        c2 = (((int)cp[0] & 0x03) << 4) + (((int)cp[1] >> 4) & 0x0f);
        c3 = (((int)cp[1] & 0x0f) << 2);

        *p++ = b64tab[c1];
        *p++ = b64tab[c2];
        *p++ = b64tab[c3];
        *p++ = '=';
    }
    else if (size == 1)
    {
        c1 = (((int)cp[0] >> 2) & 0x3f);
        c2 = (((int)cp[0] & 0x03) << 4);

        *p++ = b64tab[c1];
        *p++ = b64tab[c2];
        *p++ = '=';
        *p++ = '=';
    }
    *p = '\0';

    return(buf);
}

/*
** NSAP_NTOA -- Convert binary nsap address to ascii
** -------------------------------------------------
**
**    Returns:
**        Pointer to string.
**
**    As per RFC 1637 an nsap address is encoded in binary form
**    in the resource record. It was unclear from RFC 1348 how
**    the encoding should be. RFC 1629 defines an upper bound
**    of 20 bytes to the size of a binary nsap address.
*/

char *
nsap_ntoa(cp, size)
input u_char *cp;            /* current position in answer buf */
input int size;                /* number of bytes to extract */
{
    static char buf[3*MAXNSAP+1];
    register char *p;
    register int n;
    register int i;

    if (size > MAXNSAP)
        size = MAXNSAP;

    for (p = buf, i = 0; i < size; i++, cp++)
    {
        n = ((int)(*cp) >> 4) & 0x0f;
        *p++ = hexdigit(n);
        n = ((int)(*cp) >> 0) & 0x0f;
        *p++ = hexdigit(n);

        /* add dots for readability */
        if ((i % 2) == 0 && (i + 1) < size)
            *p++ = '.';
    }
    *p = '\0';

    return(buf);
}

/*
** IPNG_NTOA -- Convert binary ip v6 address to ascii
** --------------------------------------------------
**
**    Returns:
**        Pointer to string.
**
**    As per RFC 1886 an ip v6 address is encoded in binary form
**    in the resource record. The size is fixed.
*/

char *
ipng_ntoa(cp)
input u_char *cp;            /* current position in answer buf */
{
    static char buf[5*(IPNGSIZE/2)+1];
    register char *p;
    register int n;
    register int i;

    for (p = buf, i = 0; i < IPNGSIZE/2; i++)
    {
        n = _getshort(cp);
        cp += INT16SZ;

        (void) sprintf(p, ":%X", n);
        p += strlength(p);
    }
    *p = '\0';

    return(buf + 1);
}

/*
** PR_DATE -- Produce printable version of a clock value
** -----------------------------------------------------
**
**    Returns:
**        Pointer to string.
**
**    The value is a standard absolute clock value.
*/

char *
pr_date(value)
input int value;            /* the clock value to be converted */
{
    static char buf[sizeof("YYYYMMDDHHMMSS")+1];
    time_t clocktime = value;
    struct tm *t;

    t = gmtime(&clocktime);
    t->tm_year += 1900;
    t->tm_mon += 1;

    (void) sprintf(buf, "%04d%02d%02d%02d%02d%02d",
        t->tm_year, t->tm_mon, t->tm_mday,
        t->tm_hour, t->tm_min, t->tm_sec);

    return(buf);
}

/*
** PR_TIME -- Produce printable version of a time interval
** -------------------------------------------------------
**
**    Returns:
**        Pointer to a string version of interval.
**
**    The value is a time interval expressed in seconds.
*/

char *
pr_time(value, brief)
input int value;            /* the interval to be converted */
input bool brief;            /* use brief format if set */
{
    static char buf[256];
    register char *p = buf;
    int week, days, hour, mins, secs;

    /* special cases */
    if (value < 0)
        return("negative");
    if ((value == 0) && !brief)
        return("zero seconds");

/*
 * Decode the components.
 */
    secs = value % 60; value /= 60;
    mins = value % 60; value /= 60;
    hour = value % 24; value /= 24;
    days = value;

    if (!brief)
    {
        days = value % 7; value /= 7;
        week = value;
    }

/*
 * Now turn it into a sexy form.
 */
    if (brief)
    {
        if (days > 0)
        {
            (void) sprintf(p, "%d+", days);
            p += strlength(p);
        }

        (void) sprintf(p, "%02d:%02d:%02d", hour, mins, secs);
        return(buf);
    }

    if (week > 0)
    {
        (void) sprintf(p, ", %d week%s", week, plural(week));
        p += strlength(p);
    }

    if (days > 0)
    {
        (void) sprintf(p, ", %d day%s", days, plural(days));
        p += strlength(p);
    }

    if (hour > 0)
    {
        (void) sprintf(p, ", %d hour%s", hour, plural(hour));
        p += strlength(p);
    }

    if (mins > 0)
    {
        (void) sprintf(p, ", %d minute%s", mins, plural(mins));
        p += strlength(p);
    }

    if (secs > 0)
    {
        (void) sprintf(p, ", %d second%s", secs, plural(secs));
        /* p += strlength(p); */
    }

    return(buf + 2);
}

/*
** PR_SPHERICAL -- Produce printable version of a spherical location
** -----------------------------------------------------------------
**
**    Returns:
**        Pointer to a string version of location.
**
**    The value is a spherical location (latitude or longitude)
**    expressed in thousandths of a second of arc.
**    The value 2^31 represents zero (equator or prime meridian).
*/

char *
pr_spherical(value, pos, neg)
input int value;            /* the location to be converted */
input char *pos;            /* suffix if value positive */
input char *neg;            /* suffix if value negative */
{
    static char buf[256];
    register char *p = buf;
    char *direction;
    int degrees, minutes, seconds, fracsec;

/*
 * Normalize.
 */
    value -= (int)((unsigned)1 << 31);

    direction = pos;
    if (value < 0)
    {
        direction = neg;
        value = -value;
    }

/*
 * Decode the components.
 */
    fracsec = value % 1000; value /= 1000;
    seconds = value % 60;   value /= 60;
    minutes = value % 60;   value /= 60;
    degrees = value;

/*
 * Construct output string.
 */
    (void) sprintf(p, "%d", degrees);
    p += strlength(p);

    if (minutes > 0 || seconds > 0 || fracsec > 0)
    {
        (void) sprintf(p, " %02d", minutes);
        p += strlength(p);
    }

    if (seconds > 0 || fracsec > 0)
    {
        (void) sprintf(p, " %02d", seconds);
        p += strlength(p);
    }

    if (fracsec > 0)
    {
        (void) sprintf(p, ".%03d", fracsec);
        p += strlength(p);
    }

    (void) sprintf(p, " %s", direction);

#ifdef obsolete
    (void) sprintf(buf, "%d %02d %02d.%03d %s",
        degrees, minutes, seconds, fracsec, direction);
#endif
    return(buf);
}

/*
** PR_VERTICAL -- Produce printable version of a vertical location
** ---------------------------------------------------------------
**
**    Returns:
**        Pointer to a string version of location.
**
**    The value is an altitude expressed in centimeters, starting
**    from a base 100000 meters below the GPS reference spheroid.
**    This allows for the actual range [-10000000 .. 4293967296].
*/

char *
pr_vertical(value, pos, neg)
input int value;            /* the location to be converted */
input char *pos;            /* prefix if value positive */
input char *neg;            /* prefix if value negative */
{
    static char buf[256];
    register char *p = buf;
    char *direction;
    int meters, centimeters;
    unsigned int altitude;
    unsigned int reference;

/*
 * Normalize.
 */
    altitude = value;
    reference = 100000*100;

    if (altitude < reference)
    {
        direction = neg;
        altitude = reference - altitude;
    }
    else
    {
        direction = pos;
        altitude = altitude - reference;
    }

/*
 * Decode the components.
 */
    centimeters = altitude % 100; altitude /= 100;
    meters = altitude;

/*
 * Construct output string.
 */
    (void) sprintf(p, "%s%d", direction, meters);
    p += strlength(p);

    if (centimeters > 0)
        (void) sprintf(p, ".%02d", centimeters);

#ifdef obsolete
    (void) sprintf(buf, "%s%d.%02d", direction, meters, centimeters);
#endif
    return(buf);
}

/*
** PR_PRECISION -- Produce printable version of a location precision
** -----------------------------------------------------------------
**
**    Returns:
**        Pointer to a string version of precision.
**
**    The value is a precision expressed in centimeters, encoded
**    as 4-bit mantissa and 4-bit power of 10 (each ranging 0-9).
*/

unsigned int poweroften[10] =
{1,10,100,1000,10000,100000,1000000,10000000,100000000,1000000000};

char *
pr_precision(value)
input int value;            /* the precision to be converted */
{
    static char buf[256];
    register char *p = buf;
    int meters, centimeters;
    unsigned int precision;
    register int mantissa;
    register int exponent;

/*
 * Normalize.
 */
    mantissa = ((value >> 4) & 0x0f) % 10;
    exponent = ((value >> 0) & 0x0f) % 10;
    precision = mantissa * poweroften[exponent];

/*
 * Decode the components.
 */
    centimeters = precision % 100; precision /= 100;
    meters = precision;

/*
 * Construct output string.
 */
    (void) sprintf(p, "%d", meters);
    p += strlength(p);

    if (centimeters > 0)
        (void) sprintf(p, ".%02d", centimeters);

#ifdef obsolete
    (void) sprintf(buf, "%d.%02d", meters, centimeters);
#endif
    return(buf);
}